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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_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/license_protocol.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fexternal_5flicense_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_2fexternal_5flicense_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fexternal_5flicense_2eproto;
namespace video_widevine {
class EncryptedLicenseRequest;
struct EncryptedLicenseRequestDefaultTypeInternal;
extern EncryptedLicenseRequestDefaultTypeInternal _EncryptedLicenseRequest_default_instance_;
class ExternalLicense;
struct ExternalLicenseDefaultTypeInternal;
extern ExternalLicenseDefaultTypeInternal _ExternalLicense_default_instance_;
class ExternalLicenseCustomData;
struct ExternalLicenseCustomDataDefaultTypeInternal;
extern ExternalLicenseCustomDataDefaultTypeInternal _ExternalLicenseCustomData_default_instance_;
class ExternalLicenseRequest;
struct ExternalLicenseRequestDefaultTypeInternal;
extern ExternalLicenseRequestDefaultTypeInternal _ExternalLicenseRequest_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::EncryptedLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::EncryptedLicenseRequest>(Arena*);
template<> ::video_widevine::ExternalLicense* Arena::CreateMaybeMessage<::video_widevine::ExternalLicense>(Arena*);
template<> ::video_widevine::ExternalLicenseCustomData* Arena::CreateMaybeMessage<::video_widevine::ExternalLicenseCustomData>(Arena*);
template<> ::video_widevine::ExternalLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::ExternalLicenseRequest>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum ExternalLicenseType : int {
  EXTERNAL_LICENSE_TYPE_UNDEFINED = 0,
  PLAYREADY_LICENSE_NEW = 1,
  PLAYREADY_LICENSE_RENEWAL = 2,
  PLAYREADY_LICENSE_RELEASE = 3
};
bool ExternalLicenseType_IsValid(int value);
constexpr ExternalLicenseType ExternalLicenseType_MIN = EXTERNAL_LICENSE_TYPE_UNDEFINED;
constexpr ExternalLicenseType ExternalLicenseType_MAX = PLAYREADY_LICENSE_RELEASE;
constexpr int ExternalLicenseType_ARRAYSIZE = ExternalLicenseType_MAX + 1;

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

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

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

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

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

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

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

  EncryptedLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EncryptedLicenseRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EncryptedLicenseRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const EncryptedLicenseRequest& 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(EncryptedLicenseRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.EncryptedLicenseRequest";
  }
  protected:
  explicit EncryptedLicenseRequest(::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 {
    kProviderIdFieldNumber = 1,
    kServiceCertificateSerialNumberFieldNumber = 2,
    kEncryptedLicenseRequestFieldNumber = 3,
    kEncryptedLicenseRequestIvFieldNumber = 4,
    kEncryptedPrivacyKeyFieldNumber = 5,
  };
  // optional string provider_id = 1;
  bool has_provider_id() const;
  private:
  bool _internal_has_provider_id() const;
  public:
  void clear_provider_id();
  const std::string& provider_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_provider_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_provider_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
  void set_allocated_provider_id(std::string* provider_id);
  private:
  const std::string& _internal_provider_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
  std::string* _internal_mutable_provider_id();
  public:

  // optional bytes service_certificate_serial_number = 2;
  bool has_service_certificate_serial_number() const;
  private:
  bool _internal_has_service_certificate_serial_number() const;
  public:
  void clear_service_certificate_serial_number();
  const std::string& service_certificate_serial_number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_service_certificate_serial_number();
  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate_serial_number();
  void set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number);
  private:
  const std::string& _internal_service_certificate_serial_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate_serial_number(const std::string& value);
  std::string* _internal_mutable_service_certificate_serial_number();
  public:

  // optional bytes encrypted_license_request = 3;
  bool has_encrypted_license_request() const;
  private:
  bool _internal_has_encrypted_license_request() const;
  public:
  void clear_encrypted_license_request();
  const std::string& encrypted_license_request() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encrypted_license_request(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encrypted_license_request();
  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request();
  void set_allocated_encrypted_license_request(std::string* encrypted_license_request);
  private:
  const std::string& _internal_encrypted_license_request() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request(const std::string& value);
  std::string* _internal_mutable_encrypted_license_request();
  public:

  // optional bytes encrypted_license_request_iv = 4;
  bool has_encrypted_license_request_iv() const;
  private:
  bool _internal_has_encrypted_license_request_iv() const;
  public:
  void clear_encrypted_license_request_iv();
  const std::string& encrypted_license_request_iv() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encrypted_license_request_iv();
  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request_iv();
  void set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv);
  private:
  const std::string& _internal_encrypted_license_request_iv() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request_iv(const std::string& value);
  std::string* _internal_mutable_encrypted_license_request_iv();
  public:

  // optional bytes encrypted_privacy_key = 5;
  bool has_encrypted_privacy_key() const;
  private:
  bool _internal_has_encrypted_privacy_key() const;
  public:
  void clear_encrypted_privacy_key();
  const std::string& encrypted_privacy_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encrypted_privacy_key();
  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_privacy_key();
  void set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key);
  private:
  const std::string& _internal_encrypted_privacy_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_privacy_key(const std::string& value);
  std::string* _internal_mutable_encrypted_privacy_key();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.EncryptedLicenseRequest)
 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 provider_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_serial_number_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_iv_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ExternalLicenseRequest& operator=(const ExternalLicenseRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExternalLicenseRequest& operator=(ExternalLicenseRequest&& 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 ExternalLicenseRequest& default_instance() {
    return *internal_default_instance();
  }
  enum ClearOrEncryptedRequestCase {
    kRequest = 2,
    kEncryptedRequest = 7,
    CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET = 0,
  };

  enum ClearOrEncryptedClientIdCase {
    kClientId = 3,
    kEncryptedClientId = 4,
    CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET = 0,
  };

  static inline const ExternalLicenseRequest* internal_default_instance() {
    return reinterpret_cast<const ExternalLicenseRequest*>(
               &_ExternalLicenseRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  ExternalLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExternalLicenseRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExternalLicenseRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ExternalLicenseRequest& 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(ExternalLicenseRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.ExternalLicenseRequest";
  }
  protected:
  explicit ExternalLicenseRequest(::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 {
    kOriginalLicenseFieldNumber = 8,
    kContentIdFieldNumber = 5,
    kRequestTypeFieldNumber = 1,
    kRequestTimeFieldNumber = 6,
    kRequestFieldNumber = 2,
    kEncryptedRequestFieldNumber = 7,
    kClientIdFieldNumber = 3,
    kEncryptedClientIdFieldNumber = 4,
  };
  // optional bytes original_license = 8;
  bool has_original_license() const;
  private:
  bool _internal_has_original_license() const;
  public:
  void clear_original_license();
  const std::string& original_license() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_original_license(ArgT0&& arg0, ArgT... args);
  std::string* mutable_original_license();
  PROTOBUF_MUST_USE_RESULT std::string* release_original_license();
  void set_allocated_original_license(std::string* original_license);
  private:
  const std::string& _internal_original_license() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_original_license(const std::string& value);
  std::string* _internal_mutable_original_license();
  public:

  // optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
  bool has_content_id() const;
  private:
  bool _internal_has_content_id() const;
  public:
  void clear_content_id();
  const ::video_widevine::LicenseRequest_ContentIdentification& content_id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification* release_content_id();
  ::video_widevine::LicenseRequest_ContentIdentification* mutable_content_id();
  void set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id);
  private:
  const ::video_widevine::LicenseRequest_ContentIdentification& _internal_content_id() const;
  ::video_widevine::LicenseRequest_ContentIdentification* _internal_mutable_content_id();
  public:
  void unsafe_arena_set_allocated_content_id(
      ::video_widevine::LicenseRequest_ContentIdentification* content_id);
  ::video_widevine::LicenseRequest_ContentIdentification* unsafe_arena_release_content_id();

  // optional .video_widevine.ExternalLicenseType request_type = 1;
  bool has_request_type() const;
  private:
  bool _internal_has_request_type() const;
  public:
  void clear_request_type();
  ::video_widevine::ExternalLicenseType request_type() const;
  void set_request_type(::video_widevine::ExternalLicenseType value);
  private:
  ::video_widevine::ExternalLicenseType _internal_request_type() const;
  void _internal_set_request_type(::video_widevine::ExternalLicenseType value);
  public:

  // optional int64 request_time = 6;
  bool has_request_time() const;
  private:
  bool _internal_has_request_time() const;
  public:
  void clear_request_time();
  ::PROTOBUF_NAMESPACE_ID::int64 request_time() const;
  void set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_request_time() const;
  void _internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // bytes request = 2;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  const std::string& request() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_request(ArgT0&& arg0, ArgT... args);
  std::string* mutable_request();
  PROTOBUF_MUST_USE_RESULT std::string* release_request();
  void set_allocated_request(std::string* request);
  private:
  const std::string& _internal_request() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request(const std::string& value);
  std::string* _internal_mutable_request();
  public:

  // .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
  bool has_encrypted_request() const;
  private:
  bool _internal_has_encrypted_request() const;
  public:
  void clear_encrypted_request();
  const ::video_widevine::EncryptedLicenseRequest& encrypted_request() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedLicenseRequest* release_encrypted_request();
  ::video_widevine::EncryptedLicenseRequest* mutable_encrypted_request();
  void set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request);
  private:
  const ::video_widevine::EncryptedLicenseRequest& _internal_encrypted_request() const;
  ::video_widevine::EncryptedLicenseRequest* _internal_mutable_encrypted_request();
  public:
  void unsafe_arena_set_allocated_encrypted_request(
      ::video_widevine::EncryptedLicenseRequest* encrypted_request);
  ::video_widevine::EncryptedLicenseRequest* unsafe_arena_release_encrypted_request();

  // .video_widevine.ClientIdentification client_id = 3;
  bool has_client_id() const;
  private:
  bool _internal_has_client_id() const;
  public:
  void clear_client_id();
  const ::video_widevine::ClientIdentification& client_id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
  ::video_widevine::ClientIdentification* mutable_client_id();
  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
  private:
  const ::video_widevine::ClientIdentification& _internal_client_id() const;
  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
  public:
  void unsafe_arena_set_allocated_client_id(
      ::video_widevine::ClientIdentification* client_id);
  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();

  // .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
  bool has_encrypted_client_id() const;
  private:
  bool _internal_has_encrypted_client_id() const;
  public:
  void clear_encrypted_client_id();
  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
  private:
  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
  public:
  void unsafe_arena_set_allocated_encrypted_client_id(
      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();

  void clear_clear_or_encrypted_request();
  ClearOrEncryptedRequestCase clear_or_encrypted_request_case() const;
  void clear_clear_or_encrypted_client_id();
  ClearOrEncryptedClientIdCase clear_or_encrypted_client_id_case() const;
  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicenseRequest)
 private:
  class _Internal;
  void set_has_request();
  void set_has_encrypted_request();
  void set_has_client_id();
  void set_has_encrypted_client_id();

  inline bool has_clear_or_encrypted_request() const;
  inline void clear_has_clear_or_encrypted_request();

  inline bool has_clear_or_encrypted_client_id() const;
  inline void clear_has_clear_or_encrypted_client_id();

  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 original_license_;
  ::video_widevine::LicenseRequest_ContentIdentification* content_id_;
  int request_type_;
  ::PROTOBUF_NAMESPACE_ID::int64 request_time_;
  union ClearOrEncryptedRequestUnion {
    constexpr ClearOrEncryptedRequestUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_;
    ::video_widevine::EncryptedLicenseRequest* encrypted_request_;
  } clear_or_encrypted_request_;
  union ClearOrEncryptedClientIdUnion {
    constexpr ClearOrEncryptedClientIdUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::video_widevine::ClientIdentification* client_id_;
    ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
  } clear_or_encrypted_client_id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];

  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  ExternalLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExternalLicense>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExternalLicense& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ExternalLicense& 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(ExternalLicense* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.ExternalLicense";
  }
  protected:
  explicit ExternalLicense(::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 {
    kKeyIdFieldNumber = 5,
    kLicenseFieldNumber = 2,
    kProviderClientTokenFieldNumber = 6,
    kPolicyFieldNumber = 3,
    kLicenseStartTimeFieldNumber = 4,
    kLicenseTypeFieldNumber = 1,
  };
  // repeated bytes key_id = 5;
  int key_id_size() const;
  private:
  int _internal_key_id_size() const;
  public:
  void clear_key_id();
  const std::string& key_id(int index) const;
  std::string* mutable_key_id(int index);
  void set_key_id(int index, const std::string& value);
  void set_key_id(int index, std::string&& value);
  void set_key_id(int index, const char* value);
  void set_key_id(int index, const void* value, size_t size);
  std::string* add_key_id();
  void add_key_id(const std::string& value);
  void add_key_id(std::string&& value);
  void add_key_id(const char* value);
  void add_key_id(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_id();
  private:
  const std::string& _internal_key_id(int index) const;
  std::string* _internal_add_key_id();
  public:

  // optional bytes license = 2;
  bool has_license() const;
  private:
  bool _internal_has_license() const;
  public:
  void clear_license();
  const std::string& license() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_license(ArgT0&& arg0, ArgT... args);
  std::string* mutable_license();
  PROTOBUF_MUST_USE_RESULT std::string* release_license();
  void set_allocated_license(std::string* license);
  private:
  const std::string& _internal_license() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license(const std::string& value);
  std::string* _internal_mutable_license();
  public:

  // optional bytes provider_client_token = 6;
  bool has_provider_client_token() const;
  private:
  bool _internal_has_provider_client_token() const;
  public:
  void clear_provider_client_token();
  const std::string& provider_client_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_provider_client_token();
  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
  void set_allocated_provider_client_token(std::string* provider_client_token);
  private:
  const std::string& _internal_provider_client_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
  std::string* _internal_mutable_provider_client_token();
  public:

  // optional .video_widevine.License.Policy policy = 3;
  bool has_policy() const;
  private:
  bool _internal_has_policy() const;
  public:
  void clear_policy();
  const ::video_widevine::License_Policy& policy() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
  ::video_widevine::License_Policy* mutable_policy();
  void set_allocated_policy(::video_widevine::License_Policy* policy);
  private:
  const ::video_widevine::License_Policy& _internal_policy() const;
  ::video_widevine::License_Policy* _internal_mutable_policy();
  public:
  void unsafe_arena_set_allocated_policy(
      ::video_widevine::License_Policy* policy);
  ::video_widevine::License_Policy* unsafe_arena_release_policy();

  // optional int64 license_start_time = 4;
  bool has_license_start_time() const;
  private:
  bool _internal_has_license_start_time() const;
  public:
  void clear_license_start_time();
  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional .video_widevine.ExternalLicenseType license_type = 1;
  bool has_license_type() const;
  private:
  bool _internal_has_license_type() const;
  public:
  void clear_license_type();
  ::video_widevine::ExternalLicenseType license_type() const;
  void set_license_type(::video_widevine::ExternalLicenseType value);
  private:
  ::video_widevine::ExternalLicenseType _internal_license_type() const;
  void _internal_set_license_type(::video_widevine::ExternalLicenseType value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicense)
 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<std::string> key_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
  ::video_widevine::License_Policy* policy_;
  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
  int license_type_;
  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  ExternalLicenseCustomData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExternalLicenseCustomData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExternalLicenseCustomData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ExternalLicenseCustomData& 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(ExternalLicenseCustomData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.ExternalLicenseCustomData";
  }
  protected:
  explicit ExternalLicenseCustomData(::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 {
    kLicenseIdFieldNumber = 1,
    kOriginalPlaybackStartTimeSecondsFieldNumber = 2,
  };
  // optional .video_widevine.LicenseIdentification license_id = 1;
  bool has_license_id() const;
  private:
  bool _internal_has_license_id() const;
  public:
  void clear_license_id();
  const ::video_widevine::LicenseIdentification& license_id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
  ::video_widevine::LicenseIdentification* mutable_license_id();
  void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
  private:
  const ::video_widevine::LicenseIdentification& _internal_license_id() const;
  ::video_widevine::LicenseIdentification* _internal_mutable_license_id();
  public:
  void unsafe_arena_set_allocated_license_id(
      ::video_widevine::LicenseIdentification* license_id);
  ::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();

  // optional int64 original_playback_start_time_seconds = 2;
  bool has_original_playback_start_time_seconds() const;
  private:
  bool _internal_has_original_playback_start_time_seconds() const;
  public:
  void clear_original_playback_start_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_start_time_seconds() const;
  void set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_playback_start_time_seconds() const;
  void _internal_set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicenseCustomData)
 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::LicenseIdentification* license_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_start_time_seconds_;
  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
};
// ===================================================================


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

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

// optional string provider_id = 1;
inline bool EncryptedLicenseRequest::_internal_has_provider_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool EncryptedLicenseRequest::has_provider_id() const {
  return _internal_has_provider_id();
}
inline void EncryptedLicenseRequest::clear_provider_id() {
  provider_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& EncryptedLicenseRequest::provider_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.provider_id)
  return _internal_provider_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedLicenseRequest::set_provider_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.provider_id)
}
inline std::string* EncryptedLicenseRequest::mutable_provider_id() {
  std::string* _s = _internal_mutable_provider_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.provider_id)
  return _s;
}
inline const std::string& EncryptedLicenseRequest::_internal_provider_id() const {
  return provider_id_.Get();
}
inline void EncryptedLicenseRequest::_internal_set_provider_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::_internal_mutable_provider_id() {
  _has_bits_[0] |= 0x00000001u;
  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::release_provider_id() {
  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.provider_id)
  if (!_internal_has_provider_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void EncryptedLicenseRequest::set_allocated_provider_id(std::string* provider_id) {
  if (provider_id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.provider_id)
}

// optional bytes service_certificate_serial_number = 2;
inline bool EncryptedLicenseRequest::_internal_has_service_certificate_serial_number() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool EncryptedLicenseRequest::has_service_certificate_serial_number() const {
  return _internal_has_service_certificate_serial_number();
}
inline void EncryptedLicenseRequest::clear_service_certificate_serial_number() {
  service_certificate_serial_number_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& EncryptedLicenseRequest::service_certificate_serial_number() const {
  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
  return _internal_service_certificate_serial_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedLicenseRequest::set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 service_certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
}
inline std::string* EncryptedLicenseRequest::mutable_service_certificate_serial_number() {
  std::string* _s = _internal_mutable_service_certificate_serial_number();
  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
  return _s;
}
inline const std::string& EncryptedLicenseRequest::_internal_service_certificate_serial_number() const {
  return service_certificate_serial_number_.Get();
}
inline void EncryptedLicenseRequest::_internal_set_service_certificate_serial_number(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  service_certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::_internal_mutable_service_certificate_serial_number() {
  _has_bits_[0] |= 0x00000002u;
  return service_certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::release_service_certificate_serial_number() {
  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
  if (!_internal_has_service_certificate_serial_number()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return service_certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void EncryptedLicenseRequest::set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number) {
  if (service_certificate_serial_number != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  service_certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate_serial_number,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
}

// optional bytes encrypted_license_request = 3;
inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool EncryptedLicenseRequest::has_encrypted_license_request() const {
  return _internal_has_encrypted_license_request();
}
inline void EncryptedLicenseRequest::clear_encrypted_license_request() {
  encrypted_license_request_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& EncryptedLicenseRequest::encrypted_license_request() const {
  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
  return _internal_encrypted_license_request();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedLicenseRequest::set_encrypted_license_request(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 encrypted_license_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
}
inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request() {
  std::string* _s = _internal_mutable_encrypted_license_request();
  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
  return _s;
}
inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request() const {
  return encrypted_license_request_.Get();
}
inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  encrypted_license_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request() {
  _has_bits_[0] |= 0x00000004u;
  return encrypted_license_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::release_encrypted_license_request() {
  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
  if (!_internal_has_encrypted_license_request()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return encrypted_license_request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request(std::string* encrypted_license_request) {
  if (encrypted_license_request != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  encrypted_license_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
}

// optional bytes encrypted_license_request_iv = 4;
inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request_iv() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool EncryptedLicenseRequest::has_encrypted_license_request_iv() const {
  return _internal_has_encrypted_license_request_iv();
}
inline void EncryptedLicenseRequest::clear_encrypted_license_request_iv() {
  encrypted_license_request_iv_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& EncryptedLicenseRequest::encrypted_license_request_iv() const {
  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
  return _internal_encrypted_license_request_iv();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedLicenseRequest::set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 encrypted_license_request_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
}
inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request_iv() {
  std::string* _s = _internal_mutable_encrypted_license_request_iv();
  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
  return _s;
}
inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request_iv() const {
  return encrypted_license_request_iv_.Get();
}
inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request_iv(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  encrypted_license_request_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request_iv() {
  _has_bits_[0] |= 0x00000008u;
  return encrypted_license_request_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::release_encrypted_license_request_iv() {
  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
  if (!_internal_has_encrypted_license_request_iv()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return encrypted_license_request_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv) {
  if (encrypted_license_request_iv != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  encrypted_license_request_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request_iv,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
}

// optional bytes encrypted_privacy_key = 5;
inline bool EncryptedLicenseRequest::_internal_has_encrypted_privacy_key() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool EncryptedLicenseRequest::has_encrypted_privacy_key() const {
  return _internal_has_encrypted_privacy_key();
}
inline void EncryptedLicenseRequest::clear_encrypted_privacy_key() {
  encrypted_privacy_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& EncryptedLicenseRequest::encrypted_privacy_key() const {
  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
  return _internal_encrypted_privacy_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedLicenseRequest::set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000010u;
 encrypted_privacy_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
}
inline std::string* EncryptedLicenseRequest::mutable_encrypted_privacy_key() {
  std::string* _s = _internal_mutable_encrypted_privacy_key();
  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
  return _s;
}
inline const std::string& EncryptedLicenseRequest::_internal_encrypted_privacy_key() const {
  return encrypted_privacy_key_.Get();
}
inline void EncryptedLicenseRequest::_internal_set_encrypted_privacy_key(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  encrypted_privacy_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_privacy_key() {
  _has_bits_[0] |= 0x00000010u;
  return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* EncryptedLicenseRequest::release_encrypted_privacy_key() {
  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
  if (!_internal_has_encrypted_privacy_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return encrypted_privacy_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void EncryptedLicenseRequest::set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key) {
  if (encrypted_privacy_key != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  encrypted_privacy_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_privacy_key,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
}

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

// ExternalLicenseRequest

// optional .video_widevine.ExternalLicenseType request_type = 1;
inline bool ExternalLicenseRequest::_internal_has_request_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ExternalLicenseRequest::has_request_type() const {
  return _internal_has_request_type();
}
inline void ExternalLicenseRequest::clear_request_type() {
  request_type_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::_internal_request_type() const {
  return static_cast< ::video_widevine::ExternalLicenseType >(request_type_);
}
inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::request_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_type)
  return _internal_request_type();
}
inline void ExternalLicenseRequest::_internal_set_request_type(::video_widevine::ExternalLicenseType value) {
  assert(::video_widevine::ExternalLicenseType_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  request_type_ = value;
}
inline void ExternalLicenseRequest::set_request_type(::video_widevine::ExternalLicenseType value) {
  _internal_set_request_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_type)
}

// bytes request = 2;
inline bool ExternalLicenseRequest::_internal_has_request() const {
  return clear_or_encrypted_request_case() == kRequest;
}
inline bool ExternalLicenseRequest::has_request() const {
  return _internal_has_request();
}
inline void ExternalLicenseRequest::set_has_request() {
  _oneof_case_[0] = kRequest;
}
inline void ExternalLicenseRequest::clear_request() {
  if (_internal_has_request()) {
    clear_or_encrypted_request_.request_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_clear_or_encrypted_request();
  }
}
inline const std::string& ExternalLicenseRequest::request() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request)
  return _internal_request();
}
template <typename ArgT0, typename... ArgT>
inline void ExternalLicenseRequest::set_request(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_request()) {
    clear_clear_or_encrypted_request();
    set_has_request();
    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  clear_or_encrypted_request_.request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request)
}
inline std::string* ExternalLicenseRequest::mutable_request() {
  std::string* _s = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.request)
  return _s;
}
inline const std::string& ExternalLicenseRequest::_internal_request() const {
  if (_internal_has_request()) {
    return clear_or_encrypted_request_.request_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void ExternalLicenseRequest::_internal_set_request(const std::string& value) {
  if (!_internal_has_request()) {
    clear_clear_or_encrypted_request();
    set_has_request();
    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  clear_or_encrypted_request_.request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ExternalLicenseRequest::_internal_mutable_request() {
  if (!_internal_has_request()) {
    clear_clear_or_encrypted_request();
    set_has_request();
    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return clear_or_encrypted_request_.request_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ExternalLicenseRequest::release_request() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.request)
  if (_internal_has_request()) {
    clear_has_clear_or_encrypted_request();
    return clear_or_encrypted_request_.request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void ExternalLicenseRequest::set_allocated_request(std::string* request) {
  if (has_clear_or_encrypted_request()) {
    clear_clear_or_encrypted_request();
  }
  if (request != nullptr) {
    set_has_request();
    clear_or_encrypted_request_.request_.UnsafeSetDefault(request);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(request);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.request)
}

// .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
inline bool ExternalLicenseRequest::_internal_has_encrypted_request() const {
  return clear_or_encrypted_request_case() == kEncryptedRequest;
}
inline bool ExternalLicenseRequest::has_encrypted_request() const {
  return _internal_has_encrypted_request();
}
inline void ExternalLicenseRequest::set_has_encrypted_request() {
  _oneof_case_[0] = kEncryptedRequest;
}
inline void ExternalLicenseRequest::clear_encrypted_request() {
  if (_internal_has_encrypted_request()) {
    if (GetArenaForAllocation() == nullptr) {
      delete clear_or_encrypted_request_.encrypted_request_;
    }
    clear_has_clear_or_encrypted_request();
  }
}
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::release_encrypted_request() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_request)
  if (_internal_has_encrypted_request()) {
    clear_has_clear_or_encrypted_request();
      ::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    clear_or_encrypted_request_.encrypted_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::_internal_encrypted_request() const {
  return _internal_has_encrypted_request()
      ? *clear_or_encrypted_request_.encrypted_request_
      : reinterpret_cast< ::video_widevine::EncryptedLicenseRequest&>(::video_widevine::_EncryptedLicenseRequest_default_instance_);
}
inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::encrypted_request() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_request)
  return _internal_encrypted_request();
}
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::unsafe_arena_release_encrypted_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_request)
  if (_internal_has_encrypted_request()) {
    clear_has_clear_or_encrypted_request();
    ::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
    clear_or_encrypted_request_.encrypted_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request) {
  clear_clear_or_encrypted_request();
  if (encrypted_request) {
    set_has_encrypted_request();
    clear_or_encrypted_request_.encrypted_request_ = encrypted_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_request)
}
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::_internal_mutable_encrypted_request() {
  if (!_internal_has_encrypted_request()) {
    clear_clear_or_encrypted_request();
    set_has_encrypted_request();
    clear_or_encrypted_request_.encrypted_request_ = CreateMaybeMessage< ::video_widevine::EncryptedLicenseRequest >(GetArenaForAllocation());
  }
  return clear_or_encrypted_request_.encrypted_request_;
}
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::mutable_encrypted_request() {
  ::video_widevine::EncryptedLicenseRequest* _msg = _internal_mutable_encrypted_request();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_request)
  return _msg;
}

// .video_widevine.ClientIdentification client_id = 3;
inline bool ExternalLicenseRequest::_internal_has_client_id() const {
  return clear_or_encrypted_client_id_case() == kClientId;
}
inline bool ExternalLicenseRequest::has_client_id() const {
  return _internal_has_client_id();
}
inline void ExternalLicenseRequest::set_has_client_id() {
  _oneof_case_[1] = kClientId;
}
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::release_client_id() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.client_id)
  if (_internal_has_client_id()) {
    clear_has_clear_or_encrypted_client_id();
      ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    clear_or_encrypted_client_id_.client_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::_internal_client_id() const {
  return _internal_has_client_id()
      ? *clear_or_encrypted_client_id_.client_id_
      : reinterpret_cast< ::video_widevine::ClientIdentification&>(::video_widevine::_ClientIdentification_default_instance_);
}
inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::client_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.client_id)
  return _internal_client_id();
}
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::unsafe_arena_release_client_id() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.client_id)
  if (_internal_has_client_id()) {
    clear_has_clear_or_encrypted_client_id();
    ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
    clear_or_encrypted_client_id_.client_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
  clear_clear_or_encrypted_client_id();
  if (client_id) {
    set_has_client_id();
    clear_or_encrypted_client_id_.client_id_ = client_id;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.client_id)
}
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::_internal_mutable_client_id() {
  if (!_internal_has_client_id()) {
    clear_clear_or_encrypted_client_id();
    set_has_client_id();
    clear_or_encrypted_client_id_.client_id_ = CreateMaybeMessage< ::video_widevine::ClientIdentification >(GetArenaForAllocation());
  }
  return clear_or_encrypted_client_id_.client_id_;
}
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::mutable_client_id() {
  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.client_id)
  return _msg;
}

// .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
inline bool ExternalLicenseRequest::_internal_has_encrypted_client_id() const {
  return clear_or_encrypted_client_id_case() == kEncryptedClientId;
}
inline bool ExternalLicenseRequest::has_encrypted_client_id() const {
  return _internal_has_encrypted_client_id();
}
inline void ExternalLicenseRequest::set_has_encrypted_client_id() {
  _oneof_case_[1] = kEncryptedClientId;
}
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::release_encrypted_client_id() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
  if (_internal_has_encrypted_client_id()) {
    clear_has_clear_or_encrypted_client_id();
      ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::_internal_encrypted_client_id() const {
  return _internal_has_encrypted_client_id()
      ? *clear_or_encrypted_client_id_.encrypted_client_id_
      : reinterpret_cast< ::video_widevine::EncryptedClientIdentification&>(::video_widevine::_EncryptedClientIdentification_default_instance_);
}
inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::encrypted_client_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_client_id)
  return _internal_encrypted_client_id();
}
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::unsafe_arena_release_encrypted_client_id() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
  if (_internal_has_encrypted_client_id()) {
    clear_has_clear_or_encrypted_client_id();
    ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
  clear_clear_or_encrypted_client_id();
  if (encrypted_client_id) {
    set_has_encrypted_client_id();
    clear_or_encrypted_client_id_.encrypted_client_id_ = encrypted_client_id;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_client_id)
}
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::_internal_mutable_encrypted_client_id() {
  if (!_internal_has_encrypted_client_id()) {
    clear_clear_or_encrypted_client_id();
    set_has_encrypted_client_id();
    clear_or_encrypted_client_id_.encrypted_client_id_ = CreateMaybeMessage< ::video_widevine::EncryptedClientIdentification >(GetArenaForAllocation());
  }
  return clear_or_encrypted_client_id_.encrypted_client_id_;
}
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::mutable_encrypted_client_id() {
  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_client_id)
  return _msg;
}

// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
inline bool ExternalLicenseRequest::_internal_has_content_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || content_id_ != nullptr);
  return value;
}
inline bool ExternalLicenseRequest::has_content_id() const {
  return _internal_has_content_id();
}
inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::_internal_content_id() const {
  const ::video_widevine::LicenseRequest_ContentIdentification* p = content_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseRequest_ContentIdentification&>(
      ::video_widevine::_LicenseRequest_ContentIdentification_default_instance_);
}
inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::content_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.content_id)
  return _internal_content_id();
}
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_content_id(
    ::video_widevine::LicenseRequest_ContentIdentification* content_id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
  }
  content_id_ = content_id;
  if (content_id) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
}
inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::release_content_id() {
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
  content_id_ = 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::LicenseRequest_ContentIdentification* ExternalLicenseRequest::unsafe_arena_release_content_id() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.content_id)
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
  content_id_ = nullptr;
  return temp;
}
inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::_internal_mutable_content_id() {
  _has_bits_[0] |= 0x00000002u;
  if (content_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(GetArenaForAllocation());
    content_id_ = p;
  }
  return content_id_;
}
inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::mutable_content_id() {
  ::video_widevine::LicenseRequest_ContentIdentification* _msg = _internal_mutable_content_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.content_id)
  return _msg;
}
inline void ExternalLicenseRequest::set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
  }
  if (content_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id));
    if (message_arena != submessage_arena) {
      content_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, content_id, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  content_id_ = content_id;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
}

// optional int64 request_time = 6;
inline bool ExternalLicenseRequest::_internal_has_request_time() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ExternalLicenseRequest::has_request_time() const {
  return _internal_has_request_time();
}
inline void ExternalLicenseRequest::clear_request_time() {
  request_time_ = int64_t{0};
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::_internal_request_time() const {
  return request_time_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::request_time() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_time)
  return _internal_request_time();
}
inline void ExternalLicenseRequest::_internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  request_time_ = value;
}
inline void ExternalLicenseRequest::set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_request_time(value);
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_time)
}

// optional bytes original_license = 8;
inline bool ExternalLicenseRequest::_internal_has_original_license() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ExternalLicenseRequest::has_original_license() const {
  return _internal_has_original_license();
}
inline void ExternalLicenseRequest::clear_original_license() {
  original_license_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ExternalLicenseRequest::original_license() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.original_license)
  return _internal_original_license();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalLicenseRequest::set_original_license(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 original_license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.original_license)
}
inline std::string* ExternalLicenseRequest::mutable_original_license() {
  std::string* _s = _internal_mutable_original_license();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.original_license)
  return _s;
}
inline const std::string& ExternalLicenseRequest::_internal_original_license() const {
  return original_license_.Get();
}
inline void ExternalLicenseRequest::_internal_set_original_license(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  original_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ExternalLicenseRequest::_internal_mutable_original_license() {
  _has_bits_[0] |= 0x00000001u;
  return original_license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ExternalLicenseRequest::release_original_license() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.original_license)
  if (!_internal_has_original_license()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return original_license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ExternalLicenseRequest::set_allocated_original_license(std::string* original_license) {
  if (original_license != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  original_license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), original_license,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.original_license)
}

inline bool ExternalLicenseRequest::has_clear_or_encrypted_request() const {
  return clear_or_encrypted_request_case() != CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
}
inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_request() {
  _oneof_case_[0] = CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
}
inline bool ExternalLicenseRequest::has_clear_or_encrypted_client_id() const {
  return clear_or_encrypted_client_id_case() != CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
}
inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_client_id() {
  _oneof_case_[1] = CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
}
inline ExternalLicenseRequest::ClearOrEncryptedRequestCase ExternalLicenseRequest::clear_or_encrypted_request_case() const {
  return ExternalLicenseRequest::ClearOrEncryptedRequestCase(_oneof_case_[0]);
}
inline ExternalLicenseRequest::ClearOrEncryptedClientIdCase ExternalLicenseRequest::clear_or_encrypted_client_id_case() const {
  return ExternalLicenseRequest::ClearOrEncryptedClientIdCase(_oneof_case_[1]);
}
// -------------------------------------------------------------------

// ExternalLicense

// optional .video_widevine.ExternalLicenseType license_type = 1;
inline bool ExternalLicense::_internal_has_license_type() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ExternalLicense::has_license_type() const {
  return _internal_has_license_type();
}
inline void ExternalLicense::clear_license_type() {
  license_type_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::video_widevine::ExternalLicenseType ExternalLicense::_internal_license_type() const {
  return static_cast< ::video_widevine::ExternalLicenseType >(license_type_);
}
inline ::video_widevine::ExternalLicenseType ExternalLicense::license_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_type)
  return _internal_license_type();
}
inline void ExternalLicense::_internal_set_license_type(::video_widevine::ExternalLicenseType value) {
  assert(::video_widevine::ExternalLicenseType_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  license_type_ = value;
}
inline void ExternalLicense::set_license_type(::video_widevine::ExternalLicenseType value) {
  _internal_set_license_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_type)
}

// optional bytes license = 2;
inline bool ExternalLicense::_internal_has_license() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ExternalLicense::has_license() const {
  return _internal_has_license();
}
inline void ExternalLicense::clear_license() {
  license_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ExternalLicense::license() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license)
  return _internal_license();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalLicense::set_license(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license)
}
inline std::string* ExternalLicense::mutable_license() {
  std::string* _s = _internal_mutable_license();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.license)
  return _s;
}
inline const std::string& ExternalLicense::_internal_license() const {
  return license_.Get();
}
inline void ExternalLicense::_internal_set_license(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ExternalLicense::_internal_mutable_license() {
  _has_bits_[0] |= 0x00000001u;
  return license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ExternalLicense::release_license() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.license)
  if (!_internal_has_license()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ExternalLicense::set_allocated_license(std::string* license) {
  if (license != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.license)
}

// optional .video_widevine.License.Policy policy = 3;
inline bool ExternalLicense::_internal_has_policy() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || policy_ != nullptr);
  return value;
}
inline bool ExternalLicense::has_policy() const {
  return _internal_has_policy();
}
inline const ::video_widevine::License_Policy& ExternalLicense::_internal_policy() const {
  const ::video_widevine::License_Policy* p = policy_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
      ::video_widevine::_License_Policy_default_instance_);
}
inline const ::video_widevine::License_Policy& ExternalLicense::policy() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.policy)
  return _internal_policy();
}
inline void ExternalLicense::unsafe_arena_set_allocated_policy(
    ::video_widevine::License_Policy* policy) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
  }
  policy_ = policy;
  if (policy) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicense.policy)
}
inline ::video_widevine::License_Policy* ExternalLicense::release_policy() {
  _has_bits_[0] &= ~0x00000004u;
  ::video_widevine::License_Policy* temp = policy_;
  policy_ = 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::License_Policy* ExternalLicense::unsafe_arena_release_policy() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.policy)
  _has_bits_[0] &= ~0x00000004u;
  ::video_widevine::License_Policy* temp = policy_;
  policy_ = nullptr;
  return temp;
}
inline ::video_widevine::License_Policy* ExternalLicense::_internal_mutable_policy() {
  _has_bits_[0] |= 0x00000004u;
  if (policy_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
    policy_ = p;
  }
  return policy_;
}
inline ::video_widevine::License_Policy* ExternalLicense::mutable_policy() {
  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.policy)
  return _msg;
}
inline void ExternalLicense::set_allocated_policy(::video_widevine::License_Policy* policy) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
  }
  if (policy) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy));
    if (message_arena != submessage_arena) {
      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, policy, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  policy_ = policy;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.policy)
}

// optional int64 license_start_time = 4;
inline bool ExternalLicense::_internal_has_license_start_time() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ExternalLicense::has_license_start_time() const {
  return _internal_has_license_start_time();
}
inline void ExternalLicense::clear_license_start_time() {
  license_start_time_ = int64_t{0};
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::_internal_license_start_time() const {
  return license_start_time_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::license_start_time() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_start_time)
  return _internal_license_start_time();
}
inline void ExternalLicense::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  license_start_time_ = value;
}
inline void ExternalLicense::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_license_start_time(value);
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_start_time)
}

// repeated bytes key_id = 5;
inline int ExternalLicense::_internal_key_id_size() const {
  return key_id_.size();
}
inline int ExternalLicense::key_id_size() const {
  return _internal_key_id_size();
}
inline void ExternalLicense::clear_key_id() {
  key_id_.Clear();
}
inline std::string* ExternalLicense::add_key_id() {
  std::string* _s = _internal_add_key_id();
  // @@protoc_insertion_point(field_add_mutable:video_widevine.ExternalLicense.key_id)
  return _s;
}
inline const std::string& ExternalLicense::_internal_key_id(int index) const {
  return key_id_.Get(index);
}
inline const std::string& ExternalLicense::key_id(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.key_id)
  return _internal_key_id(index);
}
inline std::string* ExternalLicense::mutable_key_id(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.key_id)
  return key_id_.Mutable(index);
}
inline void ExternalLicense::set_key_id(int index, const std::string& value) {
  key_id_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
}
inline void ExternalLicense::set_key_id(int index, std::string&& value) {
  key_id_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
}
inline void ExternalLicense::set_key_id(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  key_id_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.ExternalLicense.key_id)
}
inline void ExternalLicense::set_key_id(int index, const void* value, size_t size) {
  key_id_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.ExternalLicense.key_id)
}
inline std::string* ExternalLicense::_internal_add_key_id() {
  return key_id_.Add();
}
inline void ExternalLicense::add_key_id(const std::string& value) {
  key_id_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
}
inline void ExternalLicense::add_key_id(std::string&& value) {
  key_id_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
}
inline void ExternalLicense::add_key_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  key_id_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.ExternalLicense.key_id)
}
inline void ExternalLicense::add_key_id(const void* value, size_t size) {
  key_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.ExternalLicense.key_id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ExternalLicense::key_id() const {
  // @@protoc_insertion_point(field_list:video_widevine.ExternalLicense.key_id)
  return key_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ExternalLicense::mutable_key_id() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.ExternalLicense.key_id)
  return &key_id_;
}

// optional bytes provider_client_token = 6;
inline bool ExternalLicense::_internal_has_provider_client_token() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ExternalLicense::has_provider_client_token() const {
  return _internal_has_provider_client_token();
}
inline void ExternalLicense::clear_provider_client_token() {
  provider_client_token_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ExternalLicense::provider_client_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.provider_client_token)
  return _internal_provider_client_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalLicense::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.provider_client_token)
}
inline std::string* ExternalLicense::mutable_provider_client_token() {
  std::string* _s = _internal_mutable_provider_client_token();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.provider_client_token)
  return _s;
}
inline const std::string& ExternalLicense::_internal_provider_client_token() const {
  return provider_client_token_.Get();
}
inline void ExternalLicense::_internal_set_provider_client_token(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ExternalLicense::_internal_mutable_provider_client_token() {
  _has_bits_[0] |= 0x00000002u;
  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ExternalLicense::release_provider_client_token() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.provider_client_token)
  if (!_internal_has_provider_client_token()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ExternalLicense::set_allocated_provider_client_token(std::string* provider_client_token) {
  if (provider_client_token != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.provider_client_token)
}

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

// ExternalLicenseCustomData

// optional .video_widevine.LicenseIdentification license_id = 1;
inline bool ExternalLicenseCustomData::_internal_has_license_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || license_id_ != nullptr);
  return value;
}
inline bool ExternalLicenseCustomData::has_license_id() const {
  return _internal_has_license_id();
}
inline const ::video_widevine::LicenseIdentification& ExternalLicenseCustomData::_internal_license_id() const {
  const ::video_widevine::LicenseIdentification* p = license_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
      ::video_widevine::_LicenseIdentification_default_instance_);
}
inline const ::video_widevine::LicenseIdentification& ExternalLicenseCustomData::license_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseCustomData.license_id)
  return _internal_license_id();
}
inline void ExternalLicenseCustomData::unsafe_arena_set_allocated_license_id(
    ::video_widevine::LicenseIdentification* license_id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
  }
  license_id_ = license_id;
  if (license_id) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseCustomData.license_id)
}
inline ::video_widevine::LicenseIdentification* ExternalLicenseCustomData::release_license_id() {
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::LicenseIdentification* temp = license_id_;
  license_id_ = 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::LicenseIdentification* ExternalLicenseCustomData::unsafe_arena_release_license_id() {
  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseCustomData.license_id)
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::LicenseIdentification* temp = license_id_;
  license_id_ = nullptr;
  return temp;
}
inline ::video_widevine::LicenseIdentification* ExternalLicenseCustomData::_internal_mutable_license_id() {
  _has_bits_[0] |= 0x00000001u;
  if (license_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
    license_id_ = p;
  }
  return license_id_;
}
inline ::video_widevine::LicenseIdentification* ExternalLicenseCustomData::mutable_license_id() {
  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseCustomData.license_id)
  return _msg;
}
inline void ExternalLicenseCustomData::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
  }
  if (license_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id));
    if (message_arena != submessage_arena) {
      license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, license_id, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  license_id_ = license_id;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseCustomData.license_id)
}

// optional int64 original_playback_start_time_seconds = 2;
inline bool ExternalLicenseCustomData::_internal_has_original_playback_start_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ExternalLicenseCustomData::has_original_playback_start_time_seconds() const {
  return _internal_has_original_playback_start_time_seconds();
}
inline void ExternalLicenseCustomData::clear_original_playback_start_time_seconds() {
  original_playback_start_time_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseCustomData::_internal_original_playback_start_time_seconds() const {
  return original_playback_start_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseCustomData::original_playback_start_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseCustomData.original_playback_start_time_seconds)
  return _internal_original_playback_start_time_seconds();
}
inline void ExternalLicenseCustomData::_internal_set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  original_playback_start_time_seconds_ = value;
}
inline void ExternalLicenseCustomData::set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_original_playback_start_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseCustomData.original_playback_start_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::ExternalLicenseType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ExternalLicenseType>() {
  return ::video_widevine::ExternalLicenseType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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