media_cas_proxy_sdk/ubuntu/protos/public/media_cas_encryption.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3014000
#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 3014000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "protos/public/hash_algorithm.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fmedia_5fcas_5fencryption_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_2fmedia_5fcas_5fencryption_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[6]
    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_2fmedia_5fcas_5fencryption_2eproto;
namespace video_widevine {
class CasEncryptionRequest;
class CasEncryptionRequestDefaultTypeInternal;
extern CasEncryptionRequestDefaultTypeInternal _CasEncryptionRequest_default_instance_;
class CasEncryptionResponse;
class CasEncryptionResponseDefaultTypeInternal;
extern CasEncryptionResponseDefaultTypeInternal _CasEncryptionResponse_default_instance_;
class CasEncryptionResponse_KeyInfo;
class CasEncryptionResponse_KeyInfoDefaultTypeInternal;
extern CasEncryptionResponse_KeyInfoDefaultTypeInternal _CasEncryptionResponse_KeyInfo_default_instance_;
class HttpResponse;
class HttpResponseDefaultTypeInternal;
extern HttpResponseDefaultTypeInternal _HttpResponse_default_instance_;
class SignedCasEncryptionRequest;
class SignedCasEncryptionRequestDefaultTypeInternal;
extern SignedCasEncryptionRequestDefaultTypeInternal _SignedCasEncryptionRequest_default_instance_;
class SignedCasEncryptionResponse;
class SignedCasEncryptionResponseDefaultTypeInternal;
extern SignedCasEncryptionResponseDefaultTypeInternal _SignedCasEncryptionResponse_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::CasEncryptionRequest* Arena::CreateMaybeMessage<::video_widevine::CasEncryptionRequest>(Arena*);
template<> ::video_widevine::CasEncryptionResponse* Arena::CreateMaybeMessage<::video_widevine::CasEncryptionResponse>(Arena*);
template<> ::video_widevine::CasEncryptionResponse_KeyInfo* Arena::CreateMaybeMessage<::video_widevine::CasEncryptionResponse_KeyInfo>(Arena*);
template<> ::video_widevine::HttpResponse* Arena::CreateMaybeMessage<::video_widevine::HttpResponse>(Arena*);
template<> ::video_widevine::SignedCasEncryptionRequest* Arena::CreateMaybeMessage<::video_widevine::SignedCasEncryptionRequest>(Arena*);
template<> ::video_widevine::SignedCasEncryptionResponse* Arena::CreateMaybeMessage<::video_widevine::SignedCasEncryptionResponse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum CasEncryptionResponse_KeyInfo_KeySlot : int {
  CasEncryptionResponse_KeyInfo_KeySlot_KEY_SLOT_UNSPECIFIED = 0,
  CasEncryptionResponse_KeyInfo_KeySlot_SINGLE = 1,
  CasEncryptionResponse_KeyInfo_KeySlot_EVEN = 2,
  CasEncryptionResponse_KeyInfo_KeySlot_ODD = 3
};
bool CasEncryptionResponse_KeyInfo_KeySlot_IsValid(int value);
constexpr CasEncryptionResponse_KeyInfo_KeySlot CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_MIN = CasEncryptionResponse_KeyInfo_KeySlot_KEY_SLOT_UNSPECIFIED;
constexpr CasEncryptionResponse_KeyInfo_KeySlot CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_MAX = CasEncryptionResponse_KeyInfo_KeySlot_ODD;
constexpr int CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_ARRAYSIZE = CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CasEncryptionResponse_KeyInfo_KeySlot_descriptor();
template<typename T>
inline const std::string& CasEncryptionResponse_KeyInfo_KeySlot_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CasEncryptionResponse_KeyInfo_KeySlot>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CasEncryptionResponse_KeyInfo_KeySlot_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CasEncryptionResponse_KeyInfo_KeySlot_descriptor(), enum_t_value);
}
inline bool CasEncryptionResponse_KeyInfo_KeySlot_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CasEncryptionResponse_KeyInfo_KeySlot* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CasEncryptionResponse_KeyInfo_KeySlot>(
    CasEncryptionResponse_KeyInfo_KeySlot_descriptor(), name, value);
}
enum CasEncryptionResponse_Status : int {
  CasEncryptionResponse_Status_STATUS_UNSPECIFIED = 0,
  CasEncryptionResponse_Status_OK = 1,
  CasEncryptionResponse_Status_SIGNATURE_FAILED = 2,
  CasEncryptionResponse_Status_ACCESS_DENIED = 3,
  CasEncryptionResponse_Status_INTERNAL_ERROR = 4,
  CasEncryptionResponse_Status_INVALID_ARGUMENT = 5,
  CasEncryptionResponse_Status_PROVIDER_ID_MISSING = 6,
  CasEncryptionResponse_Status_CONTENT_ID_MISSING = 7,
  CasEncryptionResponse_Status_TRACK_TYPE_MISSING = 8
};
bool CasEncryptionResponse_Status_IsValid(int value);
constexpr CasEncryptionResponse_Status CasEncryptionResponse_Status_Status_MIN = CasEncryptionResponse_Status_STATUS_UNSPECIFIED;
constexpr CasEncryptionResponse_Status CasEncryptionResponse_Status_Status_MAX = CasEncryptionResponse_Status_TRACK_TYPE_MISSING;
constexpr int CasEncryptionResponse_Status_Status_ARRAYSIZE = CasEncryptionResponse_Status_Status_MAX + 1;

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

class CasEncryptionRequest PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.CasEncryptionRequest) */ {
 public:
  inline CasEncryptionRequest() : CasEncryptionRequest(nullptr) {}
  virtual ~CasEncryptionRequest();

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

  inline CasEncryptionRequest& operator=(const CasEncryptionRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CasEncryptionRequest& operator=(CasEncryptionRequest&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CasEncryptionRequest& default_instance();

  static inline const CasEncryptionRequest* internal_default_instance() {
    return reinterpret_cast<const CasEncryptionRequest*>(
               &_CasEncryptionRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

  inline CasEncryptionRequest* New() const final {
    return CreateMaybeMessage<CasEncryptionRequest>(nullptr);
  }

  CasEncryptionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CasEncryptionRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CasEncryptionRequest& from);
  void MergeFrom(const CasEncryptionRequest& from);
  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:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CasEncryptionRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.CasEncryptionRequest";
  }
  protected:
  explicit CasEncryptionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto);
    return ::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTrackTypesFieldNumber = 3,
    kContentIdFieldNumber = 1,
    kProviderFieldNumber = 2,
    kGroupIdFieldNumber = 5,
    kKeyRotationFieldNumber = 4,
    kEntitlementPeriodIndexFieldNumber = 6,
  };
  // repeated string track_types = 3;
  int track_types_size() const;
  private:
  int _internal_track_types_size() const;
  public:
  void clear_track_types();
  const std::string& track_types(int index) const;
  std::string* mutable_track_types(int index);
  void set_track_types(int index, const std::string& value);
  void set_track_types(int index, std::string&& value);
  void set_track_types(int index, const char* value);
  void set_track_types(int index, const char* value, size_t size);
  std::string* add_track_types();
  void add_track_types(const std::string& value);
  void add_track_types(std::string&& value);
  void add_track_types(const char* value);
  void add_track_types(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& track_types() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_track_types();
  private:
  const std::string& _internal_track_types(int index) const;
  std::string* _internal_add_track_types();
  public:

  // optional bytes content_id = 1;
  bool has_content_id() const;
  private:
  bool _internal_has_content_id() const;
  public:
  void clear_content_id();
  const std::string& content_id() const;
  void set_content_id(const std::string& value);
  void set_content_id(std::string&& value);
  void set_content_id(const char* value);
  void set_content_id(const void* value, size_t size);
  std::string* mutable_content_id();
  std::string* release_content_id();
  void set_allocated_content_id(std::string* content_id);
  private:
  const std::string& _internal_content_id() const;
  void _internal_set_content_id(const std::string& value);
  std::string* _internal_mutable_content_id();
  public:

  // optional string provider = 2;
  bool has_provider() const;
  private:
  bool _internal_has_provider() const;
  public:
  void clear_provider();
  const std::string& provider() const;
  void set_provider(const std::string& value);
  void set_provider(std::string&& value);
  void set_provider(const char* value);
  void set_provider(const char* value, size_t size);
  std::string* mutable_provider();
  std::string* release_provider();
  void set_allocated_provider(std::string* provider);
  private:
  const std::string& _internal_provider() const;
  void _internal_set_provider(const std::string& value);
  std::string* _internal_mutable_provider();
  public:

  // optional bytes group_id = 5;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  const std::string& group_id() const;
  void set_group_id(const std::string& value);
  void set_group_id(std::string&& value);
  void set_group_id(const char* value);
  void set_group_id(const void* value, size_t size);
  std::string* mutable_group_id();
  std::string* release_group_id();
  void set_allocated_group_id(std::string* group_id);
  private:
  const std::string& _internal_group_id() const;
  void _internal_set_group_id(const std::string& value);
  std::string* _internal_mutable_group_id();
  public:

  // optional bool key_rotation = 4;
  bool has_key_rotation() const;
  private:
  bool _internal_has_key_rotation() const;
  public:
  void clear_key_rotation();
  bool key_rotation() const;
  void set_key_rotation(bool value);
  private:
  bool _internal_key_rotation() const;
  void _internal_set_key_rotation(bool value);
  public:

  // optional uint32 entitlement_period_index = 6;
  bool has_entitlement_period_index() const;
  private:
  bool _internal_has_entitlement_period_index() const;
  public:
  void clear_entitlement_period_index();
  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index() const;
  void set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_entitlement_period_index() const;
  void _internal_set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.CasEncryptionRequest)
 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> track_types_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
  bool key_rotation_;
  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index_;
  friend struct ::TableStruct_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto;
};
// -------------------------------------------------------------------

class CasEncryptionResponse_KeyInfo PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.CasEncryptionResponse.KeyInfo) */ {
 public:
  inline CasEncryptionResponse_KeyInfo() : CasEncryptionResponse_KeyInfo(nullptr) {}
  virtual ~CasEncryptionResponse_KeyInfo();

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

  inline CasEncryptionResponse_KeyInfo& operator=(const CasEncryptionResponse_KeyInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CasEncryptionResponse_KeyInfo& operator=(CasEncryptionResponse_KeyInfo&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CasEncryptionResponse_KeyInfo& default_instance();

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

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

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

  inline CasEncryptionResponse_KeyInfo* New() const final {
    return CreateMaybeMessage<CasEncryptionResponse_KeyInfo>(nullptr);
  }

  CasEncryptionResponse_KeyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CasEncryptionResponse_KeyInfo>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CasEncryptionResponse_KeyInfo& from);
  void MergeFrom(const CasEncryptionResponse_KeyInfo& from);
  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:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CasEncryptionResponse_KeyInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.CasEncryptionResponse.KeyInfo";
  }
  protected:
  explicit CasEncryptionResponse_KeyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto);
    return ::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef CasEncryptionResponse_KeyInfo_KeySlot KeySlot;
  static constexpr KeySlot KEY_SLOT_UNSPECIFIED =
    CasEncryptionResponse_KeyInfo_KeySlot_KEY_SLOT_UNSPECIFIED;
  static constexpr KeySlot SINGLE =
    CasEncryptionResponse_KeyInfo_KeySlot_SINGLE;
  static constexpr KeySlot EVEN =
    CasEncryptionResponse_KeyInfo_KeySlot_EVEN;
  static constexpr KeySlot ODD =
    CasEncryptionResponse_KeyInfo_KeySlot_ODD;
  static inline bool KeySlot_IsValid(int value) {
    return CasEncryptionResponse_KeyInfo_KeySlot_IsValid(value);
  }
  static constexpr KeySlot KeySlot_MIN =
    CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_MIN;
  static constexpr KeySlot KeySlot_MAX =
    CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_MAX;
  static constexpr int KeySlot_ARRAYSIZE =
    CasEncryptionResponse_KeyInfo_KeySlot_KeySlot_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  KeySlot_descriptor() {
    return CasEncryptionResponse_KeyInfo_KeySlot_descriptor();
  }
  template<typename T>
  static inline const std::string& KeySlot_Name(T enum_t_value) {
    static_assert(::std::is_same<T, KeySlot>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function KeySlot_Name.");
    return CasEncryptionResponse_KeyInfo_KeySlot_Name(enum_t_value);
  }
  static inline bool KeySlot_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      KeySlot* value) {
    return CasEncryptionResponse_KeyInfo_KeySlot_Parse(name, value);
  }

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

  enum : int {
    kKeyIdFieldNumber = 1,
    kKeyFieldNumber = 2,
    kTrackTypeFieldNumber = 3,
    kKeySlotFieldNumber = 4,
    kPeriodIndexFieldNumber = 5,
  };
  // optional bytes key_id = 1;
  bool has_key_id() const;
  private:
  bool _internal_has_key_id() const;
  public:
  void clear_key_id();
  const std::string& key_id() const;
  void set_key_id(const std::string& value);
  void set_key_id(std::string&& value);
  void set_key_id(const char* value);
  void set_key_id(const void* value, size_t size);
  std::string* mutable_key_id();
  std::string* release_key_id();
  void set_allocated_key_id(std::string* key_id);
  private:
  const std::string& _internal_key_id() const;
  void _internal_set_key_id(const std::string& value);
  std::string* _internal_mutable_key_id();
  public:

  // optional bytes key = 2;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // optional string track_type = 3;
  bool has_track_type() const;
  private:
  bool _internal_has_track_type() const;
  public:
  void clear_track_type();
  const std::string& track_type() const;
  void set_track_type(const std::string& value);
  void set_track_type(std::string&& value);
  void set_track_type(const char* value);
  void set_track_type(const char* value, size_t size);
  std::string* mutable_track_type();
  std::string* release_track_type();
  void set_allocated_track_type(std::string* track_type);
  private:
  const std::string& _internal_track_type() const;
  void _internal_set_track_type(const std::string& value);
  std::string* _internal_mutable_track_type();
  public:

  // optional .video_widevine.CasEncryptionResponse.KeyInfo.KeySlot key_slot = 4;
  bool has_key_slot() const;
  private:
  bool _internal_has_key_slot() const;
  public:
  void clear_key_slot();
  ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot key_slot() const;
  void set_key_slot(::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot value);
  private:
  ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot _internal_key_slot() const;
  void _internal_set_key_slot(::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot value);
  public:

  // optional uint32 period_index = 5;
  bool has_period_index() const;
  private:
  bool _internal_has_period_index() const;
  public:
  void clear_period_index();
  ::PROTOBUF_NAMESPACE_ID::uint32 period_index() const;
  void set_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_period_index() const;
  void _internal_set_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.CasEncryptionResponse.KeyInfo)
 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 key_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_type_;
  int key_slot_;
  ::PROTOBUF_NAMESPACE_ID::uint32 period_index_;
  friend struct ::TableStruct_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto;
};
// -------------------------------------------------------------------

class CasEncryptionResponse PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.CasEncryptionResponse) */ {
 public:
  inline CasEncryptionResponse() : CasEncryptionResponse(nullptr) {}
  virtual ~CasEncryptionResponse();

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

  inline CasEncryptionResponse& operator=(const CasEncryptionResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CasEncryptionResponse& operator=(CasEncryptionResponse&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CasEncryptionResponse& default_instance();

  static inline const CasEncryptionResponse* internal_default_instance() {
    return reinterpret_cast<const CasEncryptionResponse*>(
               &_CasEncryptionResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

  inline CasEncryptionResponse* New() const final {
    return CreateMaybeMessage<CasEncryptionResponse>(nullptr);
  }

  CasEncryptionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CasEncryptionResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CasEncryptionResponse& from);
  void MergeFrom(const CasEncryptionResponse& from);
  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:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CasEncryptionResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.CasEncryptionResponse";
  }
  protected:
  explicit CasEncryptionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto);
    return ::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef CasEncryptionResponse_KeyInfo KeyInfo;

  typedef CasEncryptionResponse_Status Status;
  static constexpr Status STATUS_UNSPECIFIED =
    CasEncryptionResponse_Status_STATUS_UNSPECIFIED;
  static constexpr Status OK =
    CasEncryptionResponse_Status_OK;
  static constexpr Status SIGNATURE_FAILED =
    CasEncryptionResponse_Status_SIGNATURE_FAILED;
  static constexpr Status ACCESS_DENIED =
    CasEncryptionResponse_Status_ACCESS_DENIED;
  static constexpr Status INTERNAL_ERROR =
    CasEncryptionResponse_Status_INTERNAL_ERROR;
  static constexpr Status INVALID_ARGUMENT =
    CasEncryptionResponse_Status_INVALID_ARGUMENT;
  static constexpr Status PROVIDER_ID_MISSING =
    CasEncryptionResponse_Status_PROVIDER_ID_MISSING;
  static constexpr Status CONTENT_ID_MISSING =
    CasEncryptionResponse_Status_CONTENT_ID_MISSING;
  static constexpr Status TRACK_TYPE_MISSING =
    CasEncryptionResponse_Status_TRACK_TYPE_MISSING;
  static inline bool Status_IsValid(int value) {
    return CasEncryptionResponse_Status_IsValid(value);
  }
  static constexpr Status Status_MIN =
    CasEncryptionResponse_Status_Status_MIN;
  static constexpr Status Status_MAX =
    CasEncryptionResponse_Status_Status_MAX;
  static constexpr int Status_ARRAYSIZE =
    CasEncryptionResponse_Status_Status_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Status_descriptor() {
    return CasEncryptionResponse_Status_descriptor();
  }
  template<typename T>
  static inline const std::string& Status_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Status>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Status_Name.");
    return CasEncryptionResponse_Status_Name(enum_t_value);
  }
  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Status* value) {
    return CasEncryptionResponse_Status_Parse(name, value);
  }

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

  enum : int {
    kEntitlementKeysFieldNumber = 4,
    kStatusMessageFieldNumber = 2,
    kContentIdFieldNumber = 3,
    kGroupIdFieldNumber = 5,
    kStatusFieldNumber = 1,
  };
  // repeated .video_widevine.CasEncryptionResponse.KeyInfo entitlement_keys = 4;
  int entitlement_keys_size() const;
  private:
  int _internal_entitlement_keys_size() const;
  public:
  void clear_entitlement_keys();
  ::video_widevine::CasEncryptionResponse_KeyInfo* mutable_entitlement_keys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::CasEncryptionResponse_KeyInfo >*
      mutable_entitlement_keys();
  private:
  const ::video_widevine::CasEncryptionResponse_KeyInfo& _internal_entitlement_keys(int index) const;
  ::video_widevine::CasEncryptionResponse_KeyInfo* _internal_add_entitlement_keys();
  public:
  const ::video_widevine::CasEncryptionResponse_KeyInfo& entitlement_keys(int index) const;
  ::video_widevine::CasEncryptionResponse_KeyInfo* add_entitlement_keys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::CasEncryptionResponse_KeyInfo >&
      entitlement_keys() const;

  // optional string status_message = 2;
  bool has_status_message() const;
  private:
  bool _internal_has_status_message() const;
  public:
  void clear_status_message();
  const std::string& status_message() const;
  void set_status_message(const std::string& value);
  void set_status_message(std::string&& value);
  void set_status_message(const char* value);
  void set_status_message(const char* value, size_t size);
  std::string* mutable_status_message();
  std::string* release_status_message();
  void set_allocated_status_message(std::string* status_message);
  private:
  const std::string& _internal_status_message() const;
  void _internal_set_status_message(const std::string& value);
  std::string* _internal_mutable_status_message();
  public:

  // optional bytes content_id = 3;
  bool has_content_id() const;
  private:
  bool _internal_has_content_id() const;
  public:
  void clear_content_id();
  const std::string& content_id() const;
  void set_content_id(const std::string& value);
  void set_content_id(std::string&& value);
  void set_content_id(const char* value);
  void set_content_id(const void* value, size_t size);
  std::string* mutable_content_id();
  std::string* release_content_id();
  void set_allocated_content_id(std::string* content_id);
  private:
  const std::string& _internal_content_id() const;
  void _internal_set_content_id(const std::string& value);
  std::string* _internal_mutable_content_id();
  public:

  // optional bytes group_id = 5;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  const std::string& group_id() const;
  void set_group_id(const std::string& value);
  void set_group_id(std::string&& value);
  void set_group_id(const char* value);
  void set_group_id(const void* value, size_t size);
  std::string* mutable_group_id();
  std::string* release_group_id();
  void set_allocated_group_id(std::string* group_id);
  private:
  const std::string& _internal_group_id() const;
  void _internal_set_group_id(const std::string& value);
  std::string* _internal_mutable_group_id();
  public:

  // optional .video_widevine.CasEncryptionResponse.Status status = 1;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  ::video_widevine::CasEncryptionResponse_Status status() const;
  void set_status(::video_widevine::CasEncryptionResponse_Status value);
  private:
  ::video_widevine::CasEncryptionResponse_Status _internal_status() const;
  void _internal_set_status(::video_widevine::CasEncryptionResponse_Status value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::CasEncryptionResponse_KeyInfo > entitlement_keys_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_message_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
  int status_;
  friend struct ::TableStruct_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto;
};
// -------------------------------------------------------------------

class SignedCasEncryptionRequest PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedCasEncryptionRequest) */ {
 public:
  inline SignedCasEncryptionRequest() : SignedCasEncryptionRequest(nullptr) {}
  virtual ~SignedCasEncryptionRequest();

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

  inline SignedCasEncryptionRequest& operator=(const SignedCasEncryptionRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline SignedCasEncryptionRequest& operator=(SignedCasEncryptionRequest&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SignedCasEncryptionRequest& default_instance();

  static inline const SignedCasEncryptionRequest* internal_default_instance() {
    return reinterpret_cast<const SignedCasEncryptionRequest*>(
               &_SignedCasEncryptionRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  inline SignedCasEncryptionRequest* New() const final {
    return CreateMaybeMessage<SignedCasEncryptionRequest>(nullptr);
  }

  SignedCasEncryptionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SignedCasEncryptionRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SignedCasEncryptionRequest& from);
  void MergeFrom(const SignedCasEncryptionRequest& from);
  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:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SignedCasEncryptionRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.SignedCasEncryptionRequest";
  }
  protected:
  explicit SignedCasEncryptionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto);
    return ::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRequestFieldNumber = 1,
    kSignatureFieldNumber = 2,
    kSignerFieldNumber = 3,
    kHashAlgorithmFieldNumber = 4,
  };
  // optional bytes request = 1;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  const std::string& request() const;
  void set_request(const std::string& value);
  void set_request(std::string&& value);
  void set_request(const char* value);
  void set_request(const void* value, size_t size);
  std::string* mutable_request();
  std::string* release_request();
  void set_allocated_request(std::string* request);
  private:
  const std::string& _internal_request() const;
  void _internal_set_request(const std::string& value);
  std::string* _internal_mutable_request();
  public:

  // optional bytes signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  void set_signature(const std::string& value);
  void set_signature(std::string&& value);
  void set_signature(const char* value);
  void set_signature(const void* value, size_t size);
  std::string* mutable_signature();
  std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // optional string signer = 3;
  bool has_signer() const;
  private:
  bool _internal_has_signer() const;
  public:
  void clear_signer();
  const std::string& signer() const;
  void set_signer(const std::string& value);
  void set_signer(std::string&& value);
  void set_signer(const char* value);
  void set_signer(const char* value, size_t size);
  std::string* mutable_signer();
  std::string* release_signer();
  void set_allocated_signer(std::string* signer);
  private:
  const std::string& _internal_signer() const;
  void _internal_set_signer(const std::string& value);
  std::string* _internal_mutable_signer();
  public:

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

  // @@protoc_insertion_point(class_scope:video_widevine.SignedCasEncryptionRequest)
 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 request_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signer_;
  int hash_algorithm_;
  friend struct ::TableStruct_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto;
};
// -------------------------------------------------------------------

class SignedCasEncryptionResponse PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedCasEncryptionResponse) */ {
 public:
  inline SignedCasEncryptionResponse() : SignedCasEncryptionResponse(nullptr) {}
  virtual ~SignedCasEncryptionResponse();

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

  inline SignedCasEncryptionResponse& operator=(const SignedCasEncryptionResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline SignedCasEncryptionResponse& operator=(SignedCasEncryptionResponse&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SignedCasEncryptionResponse& default_instance();

  static inline const SignedCasEncryptionResponse* internal_default_instance() {
    return reinterpret_cast<const SignedCasEncryptionResponse*>(
               &_SignedCasEncryptionResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  inline SignedCasEncryptionResponse* New() const final {
    return CreateMaybeMessage<SignedCasEncryptionResponse>(nullptr);
  }

  SignedCasEncryptionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SignedCasEncryptionResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SignedCasEncryptionResponse& from);
  void MergeFrom(const SignedCasEncryptionResponse& from);
  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:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SignedCasEncryptionResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.SignedCasEncryptionResponse";
  }
  protected:
  explicit SignedCasEncryptionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto);
    return ::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kResponseFieldNumber = 1,
    kSignatureFieldNumber = 2,
  };
  // optional bytes response = 1;
  bool has_response() const;
  private:
  bool _internal_has_response() const;
  public:
  void clear_response();
  const std::string& response() const;
  void set_response(const std::string& value);
  void set_response(std::string&& value);
  void set_response(const char* value);
  void set_response(const void* value, size_t size);
  std::string* mutable_response();
  std::string* release_response();
  void set_allocated_response(std::string* response);
  private:
  const std::string& _internal_response() const;
  void _internal_set_response(const std::string& value);
  std::string* _internal_mutable_response();
  public:

  // optional bytes signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  void set_signature(const std::string& value);
  void set_signature(std::string&& value);
  void set_signature(const char* value);
  void set_signature(const void* value, size_t size);
  std::string* mutable_signature();
  std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.SignedCasEncryptionResponse)
 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 response_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  friend struct ::TableStruct_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto;
};
// -------------------------------------------------------------------

class HttpResponse PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.HttpResponse) */ {
 public:
  inline HttpResponse() : HttpResponse(nullptr) {}
  virtual ~HttpResponse();

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

  inline HttpResponse& operator=(const HttpResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline HttpResponse& operator=(HttpResponse&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) 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 GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const HttpResponse& default_instance();

  static inline const HttpResponse* internal_default_instance() {
    return reinterpret_cast<const HttpResponse*>(
               &_HttpResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

  inline HttpResponse* New() const final {
    return CreateMaybeMessage<HttpResponse>(nullptr);
  }

  HttpResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HttpResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const HttpResponse& from);
  void MergeFrom(const HttpResponse& from);
  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:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HttpResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.HttpResponse";
  }
  protected:
  explicit HttpResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto);
    return ::descriptor_table_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kResponseFieldNumber = 1,
  };
  // optional bytes response = 1;
  bool has_response() const;
  private:
  bool _internal_has_response() const;
  public:
  void clear_response();
  const std::string& response() const;
  void set_response(const std::string& value);
  void set_response(std::string&& value);
  void set_response(const char* value);
  void set_response(const void* value, size_t size);
  std::string* mutable_response();
  std::string* release_response();
  void set_allocated_response(std::string* response);
  private:
  const std::string& _internal_response() const;
  void _internal_set_response(const std::string& value);
  std::string* _internal_mutable_response();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.HttpResponse)
 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 response_;
  friend struct ::TableStruct_protos_2fpublic_2fmedia_5fcas_5fencryption_2eproto;
};
// ===================================================================


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

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

// optional bytes content_id = 1;
inline bool CasEncryptionRequest::_internal_has_content_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CasEncryptionRequest::has_content_id() const {
  return _internal_has_content_id();
}
inline void CasEncryptionRequest::clear_content_id() {
  content_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CasEncryptionRequest::content_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionRequest.content_id)
  return _internal_content_id();
}
inline void CasEncryptionRequest::set_content_id(const std::string& value) {
  _internal_set_content_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.content_id)
}
inline std::string* CasEncryptionRequest::mutable_content_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionRequest.content_id)
  return _internal_mutable_content_id();
}
inline const std::string& CasEncryptionRequest::_internal_content_id() const {
  return content_id_.Get();
}
inline void CasEncryptionRequest::_internal_set_content_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionRequest::set_content_id(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  content_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionRequest.content_id)
}
inline void CasEncryptionRequest::set_content_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionRequest.content_id)
}
inline void CasEncryptionRequest::set_content_id(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionRequest.content_id)
}
inline std::string* CasEncryptionRequest::_internal_mutable_content_id() {
  _has_bits_[0] |= 0x00000001u;
  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionRequest::release_content_id() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionRequest.content_id)
  if (!_internal_has_content_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionRequest::set_allocated_content_id(std::string* content_id) {
  if (content_id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionRequest.content_id)
}

// optional string provider = 2;
inline bool CasEncryptionRequest::_internal_has_provider() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CasEncryptionRequest::has_provider() const {
  return _internal_has_provider();
}
inline void CasEncryptionRequest::clear_provider() {
  provider_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CasEncryptionRequest::provider() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionRequest.provider)
  return _internal_provider();
}
inline void CasEncryptionRequest::set_provider(const std::string& value) {
  _internal_set_provider(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.provider)
}
inline std::string* CasEncryptionRequest::mutable_provider() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionRequest.provider)
  return _internal_mutable_provider();
}
inline const std::string& CasEncryptionRequest::_internal_provider() const {
  return provider_.Get();
}
inline void CasEncryptionRequest::_internal_set_provider(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionRequest::set_provider(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  provider_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionRequest.provider)
}
inline void CasEncryptionRequest::set_provider(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionRequest.provider)
}
inline void CasEncryptionRequest::set_provider(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionRequest.provider)
}
inline std::string* CasEncryptionRequest::_internal_mutable_provider() {
  _has_bits_[0] |= 0x00000002u;
  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionRequest::release_provider() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionRequest.provider)
  if (!_internal_has_provider()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionRequest::set_allocated_provider(std::string* provider) {
  if (provider != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionRequest.provider)
}

// repeated string track_types = 3;
inline int CasEncryptionRequest::_internal_track_types_size() const {
  return track_types_.size();
}
inline int CasEncryptionRequest::track_types_size() const {
  return _internal_track_types_size();
}
inline void CasEncryptionRequest::clear_track_types() {
  track_types_.Clear();
}
inline std::string* CasEncryptionRequest::add_track_types() {
  // @@protoc_insertion_point(field_add_mutable:video_widevine.CasEncryptionRequest.track_types)
  return _internal_add_track_types();
}
inline const std::string& CasEncryptionRequest::_internal_track_types(int index) const {
  return track_types_.Get(index);
}
inline const std::string& CasEncryptionRequest::track_types(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionRequest.track_types)
  return _internal_track_types(index);
}
inline std::string* CasEncryptionRequest::mutable_track_types(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionRequest.track_types)
  return track_types_.Mutable(index);
}
inline void CasEncryptionRequest::set_track_types(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.track_types)
  track_types_.Mutable(index)->assign(value);
}
inline void CasEncryptionRequest::set_track_types(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.track_types)
  track_types_.Mutable(index)->assign(std::move(value));
}
inline void CasEncryptionRequest::set_track_types(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  track_types_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionRequest.track_types)
}
inline void CasEncryptionRequest::set_track_types(int index, const char* value, size_t size) {
  track_types_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionRequest.track_types)
}
inline std::string* CasEncryptionRequest::_internal_add_track_types() {
  return track_types_.Add();
}
inline void CasEncryptionRequest::add_track_types(const std::string& value) {
  track_types_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.CasEncryptionRequest.track_types)
}
inline void CasEncryptionRequest::add_track_types(std::string&& value) {
  track_types_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.CasEncryptionRequest.track_types)
}
inline void CasEncryptionRequest::add_track_types(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  track_types_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.CasEncryptionRequest.track_types)
}
inline void CasEncryptionRequest::add_track_types(const char* value, size_t size) {
  track_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.CasEncryptionRequest.track_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CasEncryptionRequest::track_types() const {
  // @@protoc_insertion_point(field_list:video_widevine.CasEncryptionRequest.track_types)
  return track_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CasEncryptionRequest::mutable_track_types() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.CasEncryptionRequest.track_types)
  return &track_types_;
}

// optional bool key_rotation = 4;
inline bool CasEncryptionRequest::_internal_has_key_rotation() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CasEncryptionRequest::has_key_rotation() const {
  return _internal_has_key_rotation();
}
inline void CasEncryptionRequest::clear_key_rotation() {
  key_rotation_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool CasEncryptionRequest::_internal_key_rotation() const {
  return key_rotation_;
}
inline bool CasEncryptionRequest::key_rotation() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionRequest.key_rotation)
  return _internal_key_rotation();
}
inline void CasEncryptionRequest::_internal_set_key_rotation(bool value) {
  _has_bits_[0] |= 0x00000008u;
  key_rotation_ = value;
}
inline void CasEncryptionRequest::set_key_rotation(bool value) {
  _internal_set_key_rotation(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.key_rotation)
}

// optional bytes group_id = 5;
inline bool CasEncryptionRequest::_internal_has_group_id() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CasEncryptionRequest::has_group_id() const {
  return _internal_has_group_id();
}
inline void CasEncryptionRequest::clear_group_id() {
  group_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CasEncryptionRequest::group_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionRequest.group_id)
  return _internal_group_id();
}
inline void CasEncryptionRequest::set_group_id(const std::string& value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.group_id)
}
inline std::string* CasEncryptionRequest::mutable_group_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionRequest.group_id)
  return _internal_mutable_group_id();
}
inline const std::string& CasEncryptionRequest::_internal_group_id() const {
  return group_id_.Get();
}
inline void CasEncryptionRequest::_internal_set_group_id(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionRequest::set_group_id(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionRequest.group_id)
}
inline void CasEncryptionRequest::set_group_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionRequest.group_id)
}
inline void CasEncryptionRequest::set_group_id(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionRequest.group_id)
}
inline std::string* CasEncryptionRequest::_internal_mutable_group_id() {
  _has_bits_[0] |= 0x00000004u;
  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionRequest::release_group_id() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionRequest.group_id)
  if (!_internal_has_group_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionRequest::set_allocated_group_id(std::string* group_id) {
  if (group_id != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionRequest.group_id)
}

// optional uint32 entitlement_period_index = 6;
inline bool CasEncryptionRequest::_internal_has_entitlement_period_index() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CasEncryptionRequest::has_entitlement_period_index() const {
  return _internal_has_entitlement_period_index();
}
inline void CasEncryptionRequest::clear_entitlement_period_index() {
  entitlement_period_index_ = 0u;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CasEncryptionRequest::_internal_entitlement_period_index() const {
  return entitlement_period_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CasEncryptionRequest::entitlement_period_index() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionRequest.entitlement_period_index)
  return _internal_entitlement_period_index();
}
inline void CasEncryptionRequest::_internal_set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000010u;
  entitlement_period_index_ = value;
}
inline void CasEncryptionRequest::set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_entitlement_period_index(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionRequest.entitlement_period_index)
}

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

// CasEncryptionResponse_KeyInfo

// optional bytes key_id = 1;
inline bool CasEncryptionResponse_KeyInfo::_internal_has_key_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CasEncryptionResponse_KeyInfo::has_key_id() const {
  return _internal_has_key_id();
}
inline void CasEncryptionResponse_KeyInfo::clear_key_id() {
  key_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CasEncryptionResponse_KeyInfo::key_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
  return _internal_key_id();
}
inline void CasEncryptionResponse_KeyInfo::set_key_id(const std::string& value) {
  _internal_set_key_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
}
inline std::string* CasEncryptionResponse_KeyInfo::mutable_key_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
  return _internal_mutable_key_id();
}
inline const std::string& CasEncryptionResponse_KeyInfo::_internal_key_id() const {
  return key_id_.Get();
}
inline void CasEncryptionResponse_KeyInfo::_internal_set_key_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionResponse_KeyInfo::set_key_id(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  key_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
}
inline void CasEncryptionResponse_KeyInfo::set_key_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
}
inline void CasEncryptionResponse_KeyInfo::set_key_id(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
}
inline std::string* CasEncryptionResponse_KeyInfo::_internal_mutable_key_id() {
  _has_bits_[0] |= 0x00000001u;
  return key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionResponse_KeyInfo::release_key_id() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
  if (!_internal_has_key_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return key_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionResponse_KeyInfo::set_allocated_key_id(std::string* key_id) {
  if (key_id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionResponse.KeyInfo.key_id)
}

// optional bytes key = 2;
inline bool CasEncryptionResponse_KeyInfo::_internal_has_key() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CasEncryptionResponse_KeyInfo::has_key() const {
  return _internal_has_key();
}
inline void CasEncryptionResponse_KeyInfo::clear_key() {
  key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CasEncryptionResponse_KeyInfo::key() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.KeyInfo.key)
  return _internal_key();
}
inline void CasEncryptionResponse_KeyInfo::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.KeyInfo.key)
}
inline std::string* CasEncryptionResponse_KeyInfo::mutable_key() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.KeyInfo.key)
  return _internal_mutable_key();
}
inline const std::string& CasEncryptionResponse_KeyInfo::_internal_key() const {
  return key_.Get();
}
inline void CasEncryptionResponse_KeyInfo::_internal_set_key(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionResponse_KeyInfo::set_key(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  key_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionResponse.KeyInfo.key)
}
inline void CasEncryptionResponse_KeyInfo::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionResponse.KeyInfo.key)
}
inline void CasEncryptionResponse_KeyInfo::set_key(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionResponse.KeyInfo.key)
}
inline std::string* CasEncryptionResponse_KeyInfo::_internal_mutable_key() {
  _has_bits_[0] |= 0x00000002u;
  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionResponse_KeyInfo::release_key() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionResponse.KeyInfo.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionResponse_KeyInfo::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionResponse.KeyInfo.key)
}

// optional string track_type = 3;
inline bool CasEncryptionResponse_KeyInfo::_internal_has_track_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CasEncryptionResponse_KeyInfo::has_track_type() const {
  return _internal_has_track_type();
}
inline void CasEncryptionResponse_KeyInfo::clear_track_type() {
  track_type_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CasEncryptionResponse_KeyInfo::track_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
  return _internal_track_type();
}
inline void CasEncryptionResponse_KeyInfo::set_track_type(const std::string& value) {
  _internal_set_track_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
}
inline std::string* CasEncryptionResponse_KeyInfo::mutable_track_type() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
  return _internal_mutable_track_type();
}
inline const std::string& CasEncryptionResponse_KeyInfo::_internal_track_type() const {
  return track_type_.Get();
}
inline void CasEncryptionResponse_KeyInfo::_internal_set_track_type(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionResponse_KeyInfo::set_track_type(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  track_type_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
}
inline void CasEncryptionResponse_KeyInfo::set_track_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
}
inline void CasEncryptionResponse_KeyInfo::set_track_type(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
}
inline std::string* CasEncryptionResponse_KeyInfo::_internal_mutable_track_type() {
  _has_bits_[0] |= 0x00000004u;
  return track_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionResponse_KeyInfo::release_track_type() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
  if (!_internal_has_track_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return track_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionResponse_KeyInfo::set_allocated_track_type(std::string* track_type) {
  if (track_type != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  track_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), track_type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionResponse.KeyInfo.track_type)
}

// optional .video_widevine.CasEncryptionResponse.KeyInfo.KeySlot key_slot = 4;
inline bool CasEncryptionResponse_KeyInfo::_internal_has_key_slot() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CasEncryptionResponse_KeyInfo::has_key_slot() const {
  return _internal_has_key_slot();
}
inline void CasEncryptionResponse_KeyInfo::clear_key_slot() {
  key_slot_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot CasEncryptionResponse_KeyInfo::_internal_key_slot() const {
  return static_cast< ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot >(key_slot_);
}
inline ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot CasEncryptionResponse_KeyInfo::key_slot() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.KeyInfo.key_slot)
  return _internal_key_slot();
}
inline void CasEncryptionResponse_KeyInfo::_internal_set_key_slot(::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot value) {
  assert(::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  key_slot_ = value;
}
inline void CasEncryptionResponse_KeyInfo::set_key_slot(::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot value) {
  _internal_set_key_slot(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.KeyInfo.key_slot)
}

// optional uint32 period_index = 5;
inline bool CasEncryptionResponse_KeyInfo::_internal_has_period_index() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CasEncryptionResponse_KeyInfo::has_period_index() const {
  return _internal_has_period_index();
}
inline void CasEncryptionResponse_KeyInfo::clear_period_index() {
  period_index_ = 0u;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CasEncryptionResponse_KeyInfo::_internal_period_index() const {
  return period_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CasEncryptionResponse_KeyInfo::period_index() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.KeyInfo.period_index)
  return _internal_period_index();
}
inline void CasEncryptionResponse_KeyInfo::_internal_set_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000010u;
  period_index_ = value;
}
inline void CasEncryptionResponse_KeyInfo::set_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_period_index(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.KeyInfo.period_index)
}

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

// CasEncryptionResponse

// optional .video_widevine.CasEncryptionResponse.Status status = 1;
inline bool CasEncryptionResponse::_internal_has_status() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CasEncryptionResponse::has_status() const {
  return _internal_has_status();
}
inline void CasEncryptionResponse::clear_status() {
  status_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::video_widevine::CasEncryptionResponse_Status CasEncryptionResponse::_internal_status() const {
  return static_cast< ::video_widevine::CasEncryptionResponse_Status >(status_);
}
inline ::video_widevine::CasEncryptionResponse_Status CasEncryptionResponse::status() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.status)
  return _internal_status();
}
inline void CasEncryptionResponse::_internal_set_status(::video_widevine::CasEncryptionResponse_Status value) {
  assert(::video_widevine::CasEncryptionResponse_Status_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  status_ = value;
}
inline void CasEncryptionResponse::set_status(::video_widevine::CasEncryptionResponse_Status value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.status)
}

// optional string status_message = 2;
inline bool CasEncryptionResponse::_internal_has_status_message() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CasEncryptionResponse::has_status_message() const {
  return _internal_has_status_message();
}
inline void CasEncryptionResponse::clear_status_message() {
  status_message_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CasEncryptionResponse::status_message() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.status_message)
  return _internal_status_message();
}
inline void CasEncryptionResponse::set_status_message(const std::string& value) {
  _internal_set_status_message(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.status_message)
}
inline std::string* CasEncryptionResponse::mutable_status_message() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.status_message)
  return _internal_mutable_status_message();
}
inline const std::string& CasEncryptionResponse::_internal_status_message() const {
  return status_message_.Get();
}
inline void CasEncryptionResponse::_internal_set_status_message(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionResponse::set_status_message(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  status_message_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionResponse.status_message)
}
inline void CasEncryptionResponse::set_status_message(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionResponse.status_message)
}
inline void CasEncryptionResponse::set_status_message(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionResponse.status_message)
}
inline std::string* CasEncryptionResponse::_internal_mutable_status_message() {
  _has_bits_[0] |= 0x00000001u;
  return status_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionResponse::release_status_message() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionResponse.status_message)
  if (!_internal_has_status_message()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return status_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionResponse::set_allocated_status_message(std::string* status_message) {
  if (status_message != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  status_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), status_message,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionResponse.status_message)
}

// optional bytes content_id = 3;
inline bool CasEncryptionResponse::_internal_has_content_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CasEncryptionResponse::has_content_id() const {
  return _internal_has_content_id();
}
inline void CasEncryptionResponse::clear_content_id() {
  content_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CasEncryptionResponse::content_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.content_id)
  return _internal_content_id();
}
inline void CasEncryptionResponse::set_content_id(const std::string& value) {
  _internal_set_content_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.content_id)
}
inline std::string* CasEncryptionResponse::mutable_content_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.content_id)
  return _internal_mutable_content_id();
}
inline const std::string& CasEncryptionResponse::_internal_content_id() const {
  return content_id_.Get();
}
inline void CasEncryptionResponse::_internal_set_content_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionResponse::set_content_id(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  content_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionResponse.content_id)
}
inline void CasEncryptionResponse::set_content_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionResponse.content_id)
}
inline void CasEncryptionResponse::set_content_id(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionResponse.content_id)
}
inline std::string* CasEncryptionResponse::_internal_mutable_content_id() {
  _has_bits_[0] |= 0x00000002u;
  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionResponse::release_content_id() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionResponse.content_id)
  if (!_internal_has_content_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionResponse::set_allocated_content_id(std::string* content_id) {
  if (content_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionResponse.content_id)
}

// repeated .video_widevine.CasEncryptionResponse.KeyInfo entitlement_keys = 4;
inline int CasEncryptionResponse::_internal_entitlement_keys_size() const {
  return entitlement_keys_.size();
}
inline int CasEncryptionResponse::entitlement_keys_size() const {
  return _internal_entitlement_keys_size();
}
inline void CasEncryptionResponse::clear_entitlement_keys() {
  entitlement_keys_.Clear();
}
inline ::video_widevine::CasEncryptionResponse_KeyInfo* CasEncryptionResponse::mutable_entitlement_keys(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.entitlement_keys)
  return entitlement_keys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::CasEncryptionResponse_KeyInfo >*
CasEncryptionResponse::mutable_entitlement_keys() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.CasEncryptionResponse.entitlement_keys)
  return &entitlement_keys_;
}
inline const ::video_widevine::CasEncryptionResponse_KeyInfo& CasEncryptionResponse::_internal_entitlement_keys(int index) const {
  return entitlement_keys_.Get(index);
}
inline const ::video_widevine::CasEncryptionResponse_KeyInfo& CasEncryptionResponse::entitlement_keys(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.entitlement_keys)
  return _internal_entitlement_keys(index);
}
inline ::video_widevine::CasEncryptionResponse_KeyInfo* CasEncryptionResponse::_internal_add_entitlement_keys() {
  return entitlement_keys_.Add();
}
inline ::video_widevine::CasEncryptionResponse_KeyInfo* CasEncryptionResponse::add_entitlement_keys() {
  // @@protoc_insertion_point(field_add:video_widevine.CasEncryptionResponse.entitlement_keys)
  return _internal_add_entitlement_keys();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::CasEncryptionResponse_KeyInfo >&
CasEncryptionResponse::entitlement_keys() const {
  // @@protoc_insertion_point(field_list:video_widevine.CasEncryptionResponse.entitlement_keys)
  return entitlement_keys_;
}

// optional bytes group_id = 5;
inline bool CasEncryptionResponse::_internal_has_group_id() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CasEncryptionResponse::has_group_id() const {
  return _internal_has_group_id();
}
inline void CasEncryptionResponse::clear_group_id() {
  group_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CasEncryptionResponse::group_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.CasEncryptionResponse.group_id)
  return _internal_group_id();
}
inline void CasEncryptionResponse::set_group_id(const std::string& value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.CasEncryptionResponse.group_id)
}
inline std::string* CasEncryptionResponse::mutable_group_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.CasEncryptionResponse.group_id)
  return _internal_mutable_group_id();
}
inline const std::string& CasEncryptionResponse::_internal_group_id() const {
  return group_id_.Get();
}
inline void CasEncryptionResponse::_internal_set_group_id(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void CasEncryptionResponse::set_group_id(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.CasEncryptionResponse.group_id)
}
inline void CasEncryptionResponse::set_group_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.CasEncryptionResponse.group_id)
}
inline void CasEncryptionResponse::set_group_id(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.CasEncryptionResponse.group_id)
}
inline std::string* CasEncryptionResponse::_internal_mutable_group_id() {
  _has_bits_[0] |= 0x00000004u;
  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* CasEncryptionResponse::release_group_id() {
  // @@protoc_insertion_point(field_release:video_widevine.CasEncryptionResponse.group_id)
  if (!_internal_has_group_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CasEncryptionResponse::set_allocated_group_id(std::string* group_id) {
  if (group_id != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.CasEncryptionResponse.group_id)
}

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

// SignedCasEncryptionRequest

// optional bytes request = 1;
inline bool SignedCasEncryptionRequest::_internal_has_request() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SignedCasEncryptionRequest::has_request() const {
  return _internal_has_request();
}
inline void SignedCasEncryptionRequest::clear_request() {
  request_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SignedCasEncryptionRequest::request() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedCasEncryptionRequest.request)
  return _internal_request();
}
inline void SignedCasEncryptionRequest::set_request(const std::string& value) {
  _internal_set_request(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedCasEncryptionRequest.request)
}
inline std::string* SignedCasEncryptionRequest::mutable_request() {
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedCasEncryptionRequest.request)
  return _internal_mutable_request();
}
inline const std::string& SignedCasEncryptionRequest::_internal_request() const {
  return request_.Get();
}
inline void SignedCasEncryptionRequest::_internal_set_request(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SignedCasEncryptionRequest::set_request(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  request_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.SignedCasEncryptionRequest.request)
}
inline void SignedCasEncryptionRequest::set_request(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.SignedCasEncryptionRequest.request)
}
inline void SignedCasEncryptionRequest::set_request(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.SignedCasEncryptionRequest.request)
}
inline std::string* SignedCasEncryptionRequest::_internal_mutable_request() {
  _has_bits_[0] |= 0x00000001u;
  return request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SignedCasEncryptionRequest::release_request() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedCasEncryptionRequest.request)
  if (!_internal_has_request()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SignedCasEncryptionRequest::set_allocated_request(std::string* request) {
  if (request != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedCasEncryptionRequest.request)
}

// optional bytes signature = 2;
inline bool SignedCasEncryptionRequest::_internal_has_signature() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SignedCasEncryptionRequest::has_signature() const {
  return _internal_has_signature();
}
inline void SignedCasEncryptionRequest::clear_signature() {
  signature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SignedCasEncryptionRequest::signature() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedCasEncryptionRequest.signature)
  return _internal_signature();
}
inline void SignedCasEncryptionRequest::set_signature(const std::string& value) {
  _internal_set_signature(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedCasEncryptionRequest.signature)
}
inline std::string* SignedCasEncryptionRequest::mutable_signature() {
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedCasEncryptionRequest.signature)
  return _internal_mutable_signature();
}
inline const std::string& SignedCasEncryptionRequest::_internal_signature() const {
  return signature_.Get();
}
inline void SignedCasEncryptionRequest::_internal_set_signature(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SignedCasEncryptionRequest::set_signature(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.SignedCasEncryptionRequest.signature)
}
inline void SignedCasEncryptionRequest::set_signature(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.SignedCasEncryptionRequest.signature)
}
inline void SignedCasEncryptionRequest::set_signature(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.SignedCasEncryptionRequest.signature)
}
inline std::string* SignedCasEncryptionRequest::_internal_mutable_signature() {
  _has_bits_[0] |= 0x00000002u;
  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SignedCasEncryptionRequest::release_signature() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedCasEncryptionRequest.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SignedCasEncryptionRequest::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedCasEncryptionRequest.signature)
}

// optional string signer = 3;
inline bool SignedCasEncryptionRequest::_internal_has_signer() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SignedCasEncryptionRequest::has_signer() const {
  return _internal_has_signer();
}
inline void SignedCasEncryptionRequest::clear_signer() {
  signer_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SignedCasEncryptionRequest::signer() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedCasEncryptionRequest.signer)
  return _internal_signer();
}
inline void SignedCasEncryptionRequest::set_signer(const std::string& value) {
  _internal_set_signer(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedCasEncryptionRequest.signer)
}
inline std::string* SignedCasEncryptionRequest::mutable_signer() {
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedCasEncryptionRequest.signer)
  return _internal_mutable_signer();
}
inline const std::string& SignedCasEncryptionRequest::_internal_signer() const {
  return signer_.Get();
}
inline void SignedCasEncryptionRequest::_internal_set_signer(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  signer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SignedCasEncryptionRequest::set_signer(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  signer_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.SignedCasEncryptionRequest.signer)
}
inline void SignedCasEncryptionRequest::set_signer(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  signer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.SignedCasEncryptionRequest.signer)
}
inline void SignedCasEncryptionRequest::set_signer(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  signer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.SignedCasEncryptionRequest.signer)
}
inline std::string* SignedCasEncryptionRequest::_internal_mutable_signer() {
  _has_bits_[0] |= 0x00000004u;
  return signer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SignedCasEncryptionRequest::release_signer() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedCasEncryptionRequest.signer)
  if (!_internal_has_signer()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return signer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SignedCasEncryptionRequest::set_allocated_signer(std::string* signer) {
  if (signer != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  signer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signer,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedCasEncryptionRequest.signer)
}

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

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

// SignedCasEncryptionResponse

// optional bytes response = 1;
inline bool SignedCasEncryptionResponse::_internal_has_response() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SignedCasEncryptionResponse::has_response() const {
  return _internal_has_response();
}
inline void SignedCasEncryptionResponse::clear_response() {
  response_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SignedCasEncryptionResponse::response() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedCasEncryptionResponse.response)
  return _internal_response();
}
inline void SignedCasEncryptionResponse::set_response(const std::string& value) {
  _internal_set_response(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedCasEncryptionResponse.response)
}
inline std::string* SignedCasEncryptionResponse::mutable_response() {
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedCasEncryptionResponse.response)
  return _internal_mutable_response();
}
inline const std::string& SignedCasEncryptionResponse::_internal_response() const {
  return response_.Get();
}
inline void SignedCasEncryptionResponse::_internal_set_response(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SignedCasEncryptionResponse::set_response(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  response_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.SignedCasEncryptionResponse.response)
}
inline void SignedCasEncryptionResponse::set_response(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.SignedCasEncryptionResponse.response)
}
inline void SignedCasEncryptionResponse::set_response(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.SignedCasEncryptionResponse.response)
}
inline std::string* SignedCasEncryptionResponse::_internal_mutable_response() {
  _has_bits_[0] |= 0x00000001u;
  return response_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SignedCasEncryptionResponse::release_response() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedCasEncryptionResponse.response)
  if (!_internal_has_response()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return response_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SignedCasEncryptionResponse::set_allocated_response(std::string* response) {
  if (response != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  response_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedCasEncryptionResponse.response)
}

// optional bytes signature = 2;
inline bool SignedCasEncryptionResponse::_internal_has_signature() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SignedCasEncryptionResponse::has_signature() const {
  return _internal_has_signature();
}
inline void SignedCasEncryptionResponse::clear_signature() {
  signature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SignedCasEncryptionResponse::signature() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedCasEncryptionResponse.signature)
  return _internal_signature();
}
inline void SignedCasEncryptionResponse::set_signature(const std::string& value) {
  _internal_set_signature(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedCasEncryptionResponse.signature)
}
inline std::string* SignedCasEncryptionResponse::mutable_signature() {
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedCasEncryptionResponse.signature)
  return _internal_mutable_signature();
}
inline const std::string& SignedCasEncryptionResponse::_internal_signature() const {
  return signature_.Get();
}
inline void SignedCasEncryptionResponse::_internal_set_signature(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SignedCasEncryptionResponse::set_signature(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.SignedCasEncryptionResponse.signature)
}
inline void SignedCasEncryptionResponse::set_signature(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.SignedCasEncryptionResponse.signature)
}
inline void SignedCasEncryptionResponse::set_signature(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.SignedCasEncryptionResponse.signature)
}
inline std::string* SignedCasEncryptionResponse::_internal_mutable_signature() {
  _has_bits_[0] |= 0x00000002u;
  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SignedCasEncryptionResponse::release_signature() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedCasEncryptionResponse.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SignedCasEncryptionResponse::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedCasEncryptionResponse.signature)
}

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

// HttpResponse

// optional bytes response = 1;
inline bool HttpResponse::_internal_has_response() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HttpResponse::has_response() const {
  return _internal_has_response();
}
inline void HttpResponse::clear_response() {
  response_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HttpResponse::response() const {
  // @@protoc_insertion_point(field_get:video_widevine.HttpResponse.response)
  return _internal_response();
}
inline void HttpResponse::set_response(const std::string& value) {
  _internal_set_response(value);
  // @@protoc_insertion_point(field_set:video_widevine.HttpResponse.response)
}
inline std::string* HttpResponse::mutable_response() {
  // @@protoc_insertion_point(field_mutable:video_widevine.HttpResponse.response)
  return _internal_mutable_response();
}
inline const std::string& HttpResponse::_internal_response() const {
  return response_.Get();
}
inline void HttpResponse::_internal_set_response(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void HttpResponse::set_response(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  response_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.HttpResponse.response)
}
inline void HttpResponse::set_response(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.HttpResponse.response)
}
inline void HttpResponse::set_response(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.HttpResponse.response)
}
inline std::string* HttpResponse::_internal_mutable_response() {
  _has_bits_[0] |= 0x00000001u;
  return response_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* HttpResponse::release_response() {
  // @@protoc_insertion_point(field_release:video_widevine.HttpResponse.response)
  if (!_internal_has_response()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return response_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void HttpResponse::set_allocated_response(std::string* response) {
  if (response != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  response_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.HttpResponse.response)
}

#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::CasEncryptionResponse_KeyInfo_KeySlot> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot>() {
  return ::video_widevine::CasEncryptionResponse_KeyInfo_KeySlot_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::CasEncryptionResponse_Status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::CasEncryptionResponse_Status>() {
  return ::video_widevine::CasEncryptionResponse_Status_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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