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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fwidevine_5fpssh_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_2fwidevine_5fpssh_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[2]
    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_2fwidevine_5fpssh_2eproto;
namespace video_widevine {
class WidevinePsshData;
class WidevinePsshDataDefaultTypeInternal;
extern WidevinePsshDataDefaultTypeInternal _WidevinePsshData_default_instance_;
class WidevinePsshData_EntitledKey;
class WidevinePsshData_EntitledKeyDefaultTypeInternal;
extern WidevinePsshData_EntitledKeyDefaultTypeInternal _WidevinePsshData_EntitledKey_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::WidevinePsshData* Arena::CreateMaybeMessage<::video_widevine::WidevinePsshData>(Arena*);
template<> ::video_widevine::WidevinePsshData_EntitledKey* Arena::CreateMaybeMessage<::video_widevine::WidevinePsshData_EntitledKey>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum WidevinePsshData_Type : int {
  WidevinePsshData_Type_SINGLE = 0,
  WidevinePsshData_Type_ENTITLEMENT = 1,
  WidevinePsshData_Type_ENTITLED_KEY = 2
};
bool WidevinePsshData_Type_IsValid(int value);
constexpr WidevinePsshData_Type WidevinePsshData_Type_Type_MIN = WidevinePsshData_Type_SINGLE;
constexpr WidevinePsshData_Type WidevinePsshData_Type_Type_MAX = WidevinePsshData_Type_ENTITLED_KEY;
constexpr int WidevinePsshData_Type_Type_ARRAYSIZE = WidevinePsshData_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WidevinePsshData_Type_descriptor();
template<typename T>
inline const std::string& WidevinePsshData_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, WidevinePsshData_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function WidevinePsshData_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    WidevinePsshData_Type_descriptor(), enum_t_value);
}
inline bool WidevinePsshData_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WidevinePsshData_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WidevinePsshData_Type>(
    WidevinePsshData_Type_descriptor(), name, value);
}
enum WidevinePsshData_Algorithm : int {
  WidevinePsshData_Algorithm_UNENCRYPTED = 0,
  WidevinePsshData_Algorithm_AESCTR = 1
};
bool WidevinePsshData_Algorithm_IsValid(int value);
constexpr WidevinePsshData_Algorithm WidevinePsshData_Algorithm_Algorithm_MIN = WidevinePsshData_Algorithm_UNENCRYPTED;
constexpr WidevinePsshData_Algorithm WidevinePsshData_Algorithm_Algorithm_MAX = WidevinePsshData_Algorithm_AESCTR;
constexpr int WidevinePsshData_Algorithm_Algorithm_ARRAYSIZE = WidevinePsshData_Algorithm_Algorithm_MAX + 1;

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

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

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

  inline WidevinePsshData_EntitledKey& operator=(const WidevinePsshData_EntitledKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline WidevinePsshData_EntitledKey& operator=(WidevinePsshData_EntitledKey&& 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 WidevinePsshData_EntitledKey& default_instance();

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

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

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

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

  WidevinePsshData_EntitledKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WidevinePsshData_EntitledKey>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WidevinePsshData_EntitledKey& from);
  void MergeFrom(const WidevinePsshData_EntitledKey& 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(WidevinePsshData_EntitledKey* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.WidevinePsshData.EntitledKey";
  }
  protected:
  explicit WidevinePsshData_EntitledKey(::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_2fwidevine_5fpssh_2eproto);
    return ::descriptor_table_protos_2fpublic_2fwidevine_5fpssh_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kEntitlementKeyIdFieldNumber = 1,
    kKeyIdFieldNumber = 2,
    kKeyFieldNumber = 3,
    kIvFieldNumber = 4,
    kEntitlementKeySizeBytesFieldNumber = 5,
  };
  // optional bytes entitlement_key_id = 1;
  bool has_entitlement_key_id() const;
  private:
  bool _internal_has_entitlement_key_id() const;
  public:
  void clear_entitlement_key_id();
  const std::string& entitlement_key_id() const;
  void set_entitlement_key_id(const std::string& value);
  void set_entitlement_key_id(std::string&& value);
  void set_entitlement_key_id(const char* value);
  void set_entitlement_key_id(const void* value, size_t size);
  std::string* mutable_entitlement_key_id();
  std::string* release_entitlement_key_id();
  void set_allocated_entitlement_key_id(std::string* entitlement_key_id);
  private:
  const std::string& _internal_entitlement_key_id() const;
  void _internal_set_entitlement_key_id(const std::string& value);
  std::string* _internal_mutable_entitlement_key_id();
  public:

  // optional bytes key_id = 2;
  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 = 3;
  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 bytes iv = 4;
  bool has_iv() const;
  private:
  bool _internal_has_iv() const;
  public:
  void clear_iv();
  const std::string& iv() const;
  void set_iv(const std::string& value);
  void set_iv(std::string&& value);
  void set_iv(const char* value);
  void set_iv(const void* value, size_t size);
  std::string* mutable_iv();
  std::string* release_iv();
  void set_allocated_iv(std::string* iv);
  private:
  const std::string& _internal_iv() const;
  void _internal_set_iv(const std::string& value);
  std::string* _internal_mutable_iv();
  public:

  // optional uint32 entitlement_key_size_bytes = 5 [default = 32];
  bool has_entitlement_key_size_bytes() const;
  private:
  bool _internal_has_entitlement_key_size_bytes() const;
  public:
  void clear_entitlement_key_size_bytes();
  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_key_size_bytes() const;
  void set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_entitlement_key_size_bytes() const;
  void _internal_set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.WidevinePsshData.EntitledKey)
 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 entitlement_key_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_key_size_bytes_;
  friend struct ::TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WidevinePsshData& operator=(const WidevinePsshData& from) {
    CopyFrom(from);
    return *this;
  }
  inline WidevinePsshData& operator=(WidevinePsshData&& 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 WidevinePsshData& default_instance();

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

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

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

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

  WidevinePsshData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WidevinePsshData>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WidevinePsshData& from);
  void MergeFrom(const WidevinePsshData& 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(WidevinePsshData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.WidevinePsshData";
  }
  protected:
  explicit WidevinePsshData(::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_2fwidevine_5fpssh_2eproto);
    return ::descriptor_table_protos_2fpublic_2fwidevine_5fpssh_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef WidevinePsshData_EntitledKey EntitledKey;

  typedef WidevinePsshData_Type Type;
  static constexpr Type SINGLE =
    WidevinePsshData_Type_SINGLE;
  static constexpr Type ENTITLEMENT =
    WidevinePsshData_Type_ENTITLEMENT;
  static constexpr Type ENTITLED_KEY =
    WidevinePsshData_Type_ENTITLED_KEY;
  static inline bool Type_IsValid(int value) {
    return WidevinePsshData_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    WidevinePsshData_Type_Type_MIN;
  static constexpr Type Type_MAX =
    WidevinePsshData_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    WidevinePsshData_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return WidevinePsshData_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return WidevinePsshData_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return WidevinePsshData_Type_Parse(name, value);
  }

  typedef WidevinePsshData_Algorithm Algorithm;
  static constexpr Algorithm UNENCRYPTED =
    WidevinePsshData_Algorithm_UNENCRYPTED;
  static constexpr Algorithm AESCTR =
    WidevinePsshData_Algorithm_AESCTR;
  static inline bool Algorithm_IsValid(int value) {
    return WidevinePsshData_Algorithm_IsValid(value);
  }
  static constexpr Algorithm Algorithm_MIN =
    WidevinePsshData_Algorithm_Algorithm_MIN;
  static constexpr Algorithm Algorithm_MAX =
    WidevinePsshData_Algorithm_Algorithm_MAX;
  static constexpr int Algorithm_ARRAYSIZE =
    WidevinePsshData_Algorithm_Algorithm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Algorithm_descriptor() {
    return WidevinePsshData_Algorithm_descriptor();
  }
  template<typename T>
  static inline const std::string& Algorithm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Algorithm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Algorithm_Name.");
    return WidevinePsshData_Algorithm_Name(enum_t_value);
  }
  static inline bool Algorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Algorithm* value) {
    return WidevinePsshData_Algorithm_Parse(name, value);
  }

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

  enum : int {
    kKeyIdsFieldNumber = 2,
    kGroupIdsFieldNumber = 13,
    kEntitledKeysFieldNumber = 14,
    kProviderFieldNumber = 3,
    kContentIdFieldNumber = 4,
    kTrackTypeFieldNumber = 5,
    kPolicyFieldNumber = 6,
    kGroupedLicenseFieldNumber = 8,
    kVideoFeatureFieldNumber = 15,
    kAudioFeatureFieldNumber = 16,
    kAlgorithmFieldNumber = 1,
    kCryptoPeriodIndexFieldNumber = 7,
    kProtectionSchemeFieldNumber = 9,
    kCryptoPeriodSecondsFieldNumber = 10,
    kTypeFieldNumber = 11,
    kKeySequenceFieldNumber = 12,
    kEntitlementPeriodIndexFieldNumber = 17,
  };
  // repeated bytes key_ids = 2;
  int key_ids_size() const;
  private:
  int _internal_key_ids_size() const;
  public:
  void clear_key_ids();
  const std::string& key_ids(int index) const;
  std::string* mutable_key_ids(int index);
  void set_key_ids(int index, const std::string& value);
  void set_key_ids(int index, std::string&& value);
  void set_key_ids(int index, const char* value);
  void set_key_ids(int index, const void* value, size_t size);
  std::string* add_key_ids();
  void add_key_ids(const std::string& value);
  void add_key_ids(std::string&& value);
  void add_key_ids(const char* value);
  void add_key_ids(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_ids();
  private:
  const std::string& _internal_key_ids(int index) const;
  std::string* _internal_add_key_ids();
  public:

  // repeated bytes group_ids = 13;
  int group_ids_size() const;
  private:
  int _internal_group_ids_size() const;
  public:
  void clear_group_ids();
  const std::string& group_ids(int index) const;
  std::string* mutable_group_ids(int index);
  void set_group_ids(int index, const std::string& value);
  void set_group_ids(int index, std::string&& value);
  void set_group_ids(int index, const char* value);
  void set_group_ids(int index, const void* value, size_t size);
  std::string* add_group_ids();
  void add_group_ids(const std::string& value);
  void add_group_ids(std::string&& value);
  void add_group_ids(const char* value);
  void add_group_ids(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& group_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_group_ids();
  private:
  const std::string& _internal_group_ids(int index) const;
  std::string* _internal_add_group_ids();
  public:

  // repeated .video_widevine.WidevinePsshData.EntitledKey entitled_keys = 14;
  int entitled_keys_size() const;
  private:
  int _internal_entitled_keys_size() const;
  public:
  void clear_entitled_keys();
  ::video_widevine::WidevinePsshData_EntitledKey* mutable_entitled_keys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >*
      mutable_entitled_keys();
  private:
  const ::video_widevine::WidevinePsshData_EntitledKey& _internal_entitled_keys(int index) const;
  ::video_widevine::WidevinePsshData_EntitledKey* _internal_add_entitled_keys();
  public:
  const ::video_widevine::WidevinePsshData_EntitledKey& entitled_keys(int index) const;
  ::video_widevine::WidevinePsshData_EntitledKey* add_entitled_keys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >&
      entitled_keys() const;

  // optional string provider = 3 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_provider() const;
  private:
  bool _internal_has_provider() const;
  public:
  PROTOBUF_DEPRECATED void clear_provider();
  PROTOBUF_DEPRECATED const std::string& provider() const;
  PROTOBUF_DEPRECATED void set_provider(const std::string& value);
  PROTOBUF_DEPRECATED void set_provider(std::string&& value);
  PROTOBUF_DEPRECATED void set_provider(const char* value);
  PROTOBUF_DEPRECATED void set_provider(const char* value, size_t size);
  PROTOBUF_DEPRECATED std::string* mutable_provider();
  PROTOBUF_DEPRECATED std::string* release_provider();
  PROTOBUF_DEPRECATED 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 content_id = 4;
  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 track_type = 5 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_track_type() const;
  private:
  bool _internal_has_track_type() const;
  public:
  PROTOBUF_DEPRECATED void clear_track_type();
  PROTOBUF_DEPRECATED const std::string& track_type() const;
  PROTOBUF_DEPRECATED void set_track_type(const std::string& value);
  PROTOBUF_DEPRECATED void set_track_type(std::string&& value);
  PROTOBUF_DEPRECATED void set_track_type(const char* value);
  PROTOBUF_DEPRECATED void set_track_type(const char* value, size_t size);
  PROTOBUF_DEPRECATED std::string* mutable_track_type();
  PROTOBUF_DEPRECATED std::string* release_track_type();
  PROTOBUF_DEPRECATED 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 string policy = 6 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_policy() const;
  private:
  bool _internal_has_policy() const;
  public:
  PROTOBUF_DEPRECATED void clear_policy();
  PROTOBUF_DEPRECATED const std::string& policy() const;
  PROTOBUF_DEPRECATED void set_policy(const std::string& value);
  PROTOBUF_DEPRECATED void set_policy(std::string&& value);
  PROTOBUF_DEPRECATED void set_policy(const char* value);
  PROTOBUF_DEPRECATED void set_policy(const char* value, size_t size);
  PROTOBUF_DEPRECATED std::string* mutable_policy();
  PROTOBUF_DEPRECATED std::string* release_policy();
  PROTOBUF_DEPRECATED void set_allocated_policy(std::string* policy);
  private:
  const std::string& _internal_policy() const;
  void _internal_set_policy(const std::string& value);
  std::string* _internal_mutable_policy();
  public:

  // optional bytes grouped_license = 8 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_grouped_license() const;
  private:
  bool _internal_has_grouped_license() const;
  public:
  PROTOBUF_DEPRECATED void clear_grouped_license();
  PROTOBUF_DEPRECATED const std::string& grouped_license() const;
  PROTOBUF_DEPRECATED void set_grouped_license(const std::string& value);
  PROTOBUF_DEPRECATED void set_grouped_license(std::string&& value);
  PROTOBUF_DEPRECATED void set_grouped_license(const char* value);
  PROTOBUF_DEPRECATED void set_grouped_license(const void* value, size_t size);
  PROTOBUF_DEPRECATED std::string* mutable_grouped_license();
  PROTOBUF_DEPRECATED std::string* release_grouped_license();
  PROTOBUF_DEPRECATED void set_allocated_grouped_license(std::string* grouped_license);
  private:
  const std::string& _internal_grouped_license() const;
  void _internal_set_grouped_license(const std::string& value);
  std::string* _internal_mutable_grouped_license();
  public:

  // optional string video_feature = 15;
  bool has_video_feature() const;
  private:
  bool _internal_has_video_feature() const;
  public:
  void clear_video_feature();
  const std::string& video_feature() const;
  void set_video_feature(const std::string& value);
  void set_video_feature(std::string&& value);
  void set_video_feature(const char* value);
  void set_video_feature(const char* value, size_t size);
  std::string* mutable_video_feature();
  std::string* release_video_feature();
  void set_allocated_video_feature(std::string* video_feature);
  private:
  const std::string& _internal_video_feature() const;
  void _internal_set_video_feature(const std::string& value);
  std::string* _internal_mutable_video_feature();
  public:

  // optional string audio_feature = 16;
  bool has_audio_feature() const;
  private:
  bool _internal_has_audio_feature() const;
  public:
  void clear_audio_feature();
  const std::string& audio_feature() const;
  void set_audio_feature(const std::string& value);
  void set_audio_feature(std::string&& value);
  void set_audio_feature(const char* value);
  void set_audio_feature(const char* value, size_t size);
  std::string* mutable_audio_feature();
  std::string* release_audio_feature();
  void set_allocated_audio_feature(std::string* audio_feature);
  private:
  const std::string& _internal_audio_feature() const;
  void _internal_set_audio_feature(const std::string& value);
  std::string* _internal_mutable_audio_feature();
  public:

  // optional .video_widevine.WidevinePsshData.Algorithm algorithm = 1 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_algorithm() const;
  private:
  bool _internal_has_algorithm() const;
  public:
  PROTOBUF_DEPRECATED void clear_algorithm();
  PROTOBUF_DEPRECATED ::video_widevine::WidevinePsshData_Algorithm algorithm() const;
  PROTOBUF_DEPRECATED void set_algorithm(::video_widevine::WidevinePsshData_Algorithm value);
  private:
  ::video_widevine::WidevinePsshData_Algorithm _internal_algorithm() const;
  void _internal_set_algorithm(::video_widevine::WidevinePsshData_Algorithm value);
  public:

  // optional uint32 crypto_period_index = 7;
  bool has_crypto_period_index() const;
  private:
  bool _internal_has_crypto_period_index() const;
  public:
  void clear_crypto_period_index();
  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_index() const;
  void set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_crypto_period_index() const;
  void _internal_set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional uint32 protection_scheme = 9;
  bool has_protection_scheme() const;
  private:
  bool _internal_has_protection_scheme() const;
  public:
  void clear_protection_scheme();
  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme() const;
  void set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protection_scheme() const;
  void _internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional uint32 crypto_period_seconds = 10;
  bool has_crypto_period_seconds() const;
  private:
  bool _internal_has_crypto_period_seconds() const;
  public:
  void clear_crypto_period_seconds();
  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_seconds() const;
  void set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_crypto_period_seconds() const;
  void _internal_set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.WidevinePsshData.Type type = 11 [default = SINGLE];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::video_widevine::WidevinePsshData_Type type() const;
  void set_type(::video_widevine::WidevinePsshData_Type value);
  private:
  ::video_widevine::WidevinePsshData_Type _internal_type() const;
  void _internal_set_type(::video_widevine::WidevinePsshData_Type value);
  public:

  // optional uint32 key_sequence = 12;
  bool has_key_sequence() const;
  private:
  bool _internal_has_key_sequence() const;
  public:
  void clear_key_sequence();
  ::PROTOBUF_NAMESPACE_ID::uint32 key_sequence() const;
  void set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_sequence() const;
  void _internal_set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional uint32 entitlement_period_index = 17;
  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.WidevinePsshData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_ids_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> group_ids_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey > entitled_keys_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr grouped_license_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr video_feature_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr audio_feature_;
  int algorithm_;
  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_index_;
  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_seconds_;
  int type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 key_sequence_;
  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index_;
  friend struct ::TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto;
};
// ===================================================================


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

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

// optional bytes entitlement_key_id = 1;
inline bool WidevinePsshData_EntitledKey::_internal_has_entitlement_key_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WidevinePsshData_EntitledKey::has_entitlement_key_id() const {
  return _internal_has_entitlement_key_id();
}
inline void WidevinePsshData_EntitledKey::clear_entitlement_key_id() {
  entitlement_key_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& WidevinePsshData_EntitledKey::entitlement_key_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
  return _internal_entitlement_key_id();
}
inline void WidevinePsshData_EntitledKey::set_entitlement_key_id(const std::string& value) {
  _internal_set_entitlement_key_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
}
inline std::string* WidevinePsshData_EntitledKey::mutable_entitlement_key_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
  return _internal_mutable_entitlement_key_id();
}
inline const std::string& WidevinePsshData_EntitledKey::_internal_entitlement_key_id() const {
  return entitlement_key_id_.Get();
}
inline void WidevinePsshData_EntitledKey::_internal_set_entitlement_key_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  entitlement_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WidevinePsshData_EntitledKey::set_entitlement_key_id(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  entitlement_key_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
}
inline void WidevinePsshData_EntitledKey::set_entitlement_key_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  entitlement_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
}
inline void WidevinePsshData_EntitledKey::set_entitlement_key_id(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  entitlement_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.WidevinePsshData.EntitledKey.entitlement_key_id)
}
inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_entitlement_key_id() {
  _has_bits_[0] |= 0x00000001u;
  return entitlement_key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData_EntitledKey::release_entitlement_key_id() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
  if (!_internal_has_entitlement_key_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return entitlement_key_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WidevinePsshData_EntitledKey::set_allocated_entitlement_key_id(std::string* entitlement_key_id) {
  if (entitlement_key_id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  entitlement_key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), entitlement_key_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
}

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

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

// optional bytes iv = 4;
inline bool WidevinePsshData_EntitledKey::_internal_has_iv() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool WidevinePsshData_EntitledKey::has_iv() const {
  return _internal_has_iv();
}
inline void WidevinePsshData_EntitledKey::clear_iv() {
  iv_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& WidevinePsshData_EntitledKey::iv() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.iv)
  return _internal_iv();
}
inline void WidevinePsshData_EntitledKey::set_iv(const std::string& value) {
  _internal_set_iv(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.iv)
}
inline std::string* WidevinePsshData_EntitledKey::mutable_iv() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.iv)
  return _internal_mutable_iv();
}
inline const std::string& WidevinePsshData_EntitledKey::_internal_iv() const {
  return iv_.Get();
}
inline void WidevinePsshData_EntitledKey::_internal_set_iv(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WidevinePsshData_EntitledKey::set_iv(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  iv_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.WidevinePsshData.EntitledKey.iv)
}
inline void WidevinePsshData_EntitledKey::set_iv(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.EntitledKey.iv)
}
inline void WidevinePsshData_EntitledKey::set_iv(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.EntitledKey.iv)
}
inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_iv() {
  _has_bits_[0] |= 0x00000008u;
  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData_EntitledKey::release_iv() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.iv)
  if (!_internal_has_iv()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WidevinePsshData_EntitledKey::set_allocated_iv(std::string* iv) {
  if (iv != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.iv)
}

// optional uint32 entitlement_key_size_bytes = 5 [default = 32];
inline bool WidevinePsshData_EntitledKey::_internal_has_entitlement_key_size_bytes() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool WidevinePsshData_EntitledKey::has_entitlement_key_size_bytes() const {
  return _internal_has_entitlement_key_size_bytes();
}
inline void WidevinePsshData_EntitledKey::clear_entitlement_key_size_bytes() {
  entitlement_key_size_bytes_ = 32u;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData_EntitledKey::_internal_entitlement_key_size_bytes() const {
  return entitlement_key_size_bytes_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData_EntitledKey::entitlement_key_size_bytes() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_size_bytes)
  return _internal_entitlement_key_size_bytes();
}
inline void WidevinePsshData_EntitledKey::_internal_set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000010u;
  entitlement_key_size_bytes_ = value;
}
inline void WidevinePsshData_EntitledKey::set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_entitlement_key_size_bytes(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_size_bytes)
}

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

// WidevinePsshData

// repeated bytes key_ids = 2;
inline int WidevinePsshData::_internal_key_ids_size() const {
  return key_ids_.size();
}
inline int WidevinePsshData::key_ids_size() const {
  return _internal_key_ids_size();
}
inline void WidevinePsshData::clear_key_ids() {
  key_ids_.Clear();
}
inline std::string* WidevinePsshData::add_key_ids() {
  // @@protoc_insertion_point(field_add_mutable:video_widevine.WidevinePsshData.key_ids)
  return _internal_add_key_ids();
}
inline const std::string& WidevinePsshData::_internal_key_ids(int index) const {
  return key_ids_.Get(index);
}
inline const std::string& WidevinePsshData::key_ids(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.key_ids)
  return _internal_key_ids(index);
}
inline std::string* WidevinePsshData::mutable_key_ids(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.key_ids)
  return key_ids_.Mutable(index);
}
inline void WidevinePsshData::set_key_ids(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_ids)
  key_ids_.Mutable(index)->assign(value);
}
inline void WidevinePsshData::set_key_ids(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_ids)
  key_ids_.Mutable(index)->assign(std::move(value));
}
inline void WidevinePsshData::set_key_ids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  key_ids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.key_ids)
}
inline void WidevinePsshData::set_key_ids(int index, const void* value, size_t size) {
  key_ids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.key_ids)
}
inline std::string* WidevinePsshData::_internal_add_key_ids() {
  return key_ids_.Add();
}
inline void WidevinePsshData::add_key_ids(const std::string& value) {
  key_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.key_ids)
}
inline void WidevinePsshData::add_key_ids(std::string&& value) {
  key_ids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.key_ids)
}
inline void WidevinePsshData::add_key_ids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  key_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.WidevinePsshData.key_ids)
}
inline void WidevinePsshData::add_key_ids(const void* value, size_t size) {
  key_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.WidevinePsshData.key_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
WidevinePsshData::key_ids() const {
  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.key_ids)
  return key_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
WidevinePsshData::mutable_key_ids() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.key_ids)
  return &key_ids_;
}

// optional bytes content_id = 4;
inline bool WidevinePsshData::_internal_has_content_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WidevinePsshData::has_content_id() const {
  return _internal_has_content_id();
}
inline void WidevinePsshData::clear_content_id() {
  content_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& WidevinePsshData::content_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.content_id)
  return _internal_content_id();
}
inline void WidevinePsshData::set_content_id(const std::string& value) {
  _internal_set_content_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.content_id)
}
inline std::string* WidevinePsshData::mutable_content_id() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.content_id)
  return _internal_mutable_content_id();
}
inline const std::string& WidevinePsshData::_internal_content_id() const {
  return content_id_.Get();
}
inline void WidevinePsshData::_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 WidevinePsshData::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.WidevinePsshData.content_id)
}
inline void WidevinePsshData::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.WidevinePsshData.content_id)
}
inline void WidevinePsshData::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.WidevinePsshData.content_id)
}
inline std::string* WidevinePsshData::_internal_mutable_content_id() {
  _has_bits_[0] |= 0x00000002u;
  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData::release_content_id() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.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 WidevinePsshData::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.WidevinePsshData.content_id)
}

// optional uint32 crypto_period_index = 7;
inline bool WidevinePsshData::_internal_has_crypto_period_index() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool WidevinePsshData::has_crypto_period_index() const {
  return _internal_has_crypto_period_index();
}
inline void WidevinePsshData::clear_crypto_period_index() {
  crypto_period_index_ = 0u;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_crypto_period_index() const {
  return crypto_period_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::crypto_period_index() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.crypto_period_index)
  return _internal_crypto_period_index();
}
inline void WidevinePsshData::_internal_set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000100u;
  crypto_period_index_ = value;
}
inline void WidevinePsshData::set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_crypto_period_index(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.crypto_period_index)
}

// optional uint32 protection_scheme = 9;
inline bool WidevinePsshData::_internal_has_protection_scheme() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool WidevinePsshData::has_protection_scheme() const {
  return _internal_has_protection_scheme();
}
inline void WidevinePsshData::clear_protection_scheme() {
  protection_scheme_ = 0u;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_protection_scheme() const {
  return protection_scheme_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::protection_scheme() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.protection_scheme)
  return _internal_protection_scheme();
}
inline void WidevinePsshData::_internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000200u;
  protection_scheme_ = value;
}
inline void WidevinePsshData::set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_protection_scheme(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.protection_scheme)
}

// optional uint32 crypto_period_seconds = 10;
inline bool WidevinePsshData::_internal_has_crypto_period_seconds() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool WidevinePsshData::has_crypto_period_seconds() const {
  return _internal_has_crypto_period_seconds();
}
inline void WidevinePsshData::clear_crypto_period_seconds() {
  crypto_period_seconds_ = 0u;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_crypto_period_seconds() const {
  return crypto_period_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::crypto_period_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.crypto_period_seconds)
  return _internal_crypto_period_seconds();
}
inline void WidevinePsshData::_internal_set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000400u;
  crypto_period_seconds_ = value;
}
inline void WidevinePsshData::set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_crypto_period_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.crypto_period_seconds)
}

// optional .video_widevine.WidevinePsshData.Type type = 11 [default = SINGLE];
inline bool WidevinePsshData::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool WidevinePsshData::has_type() const {
  return _internal_has_type();
}
inline void WidevinePsshData::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::video_widevine::WidevinePsshData_Type WidevinePsshData::_internal_type() const {
  return static_cast< ::video_widevine::WidevinePsshData_Type >(type_);
}
inline ::video_widevine::WidevinePsshData_Type WidevinePsshData::type() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.type)
  return _internal_type();
}
inline void WidevinePsshData::_internal_set_type(::video_widevine::WidevinePsshData_Type value) {
  assert(::video_widevine::WidevinePsshData_Type_IsValid(value));
  _has_bits_[0] |= 0x00000800u;
  type_ = value;
}
inline void WidevinePsshData::set_type(::video_widevine::WidevinePsshData_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.type)
}

// optional uint32 key_sequence = 12;
inline bool WidevinePsshData::_internal_has_key_sequence() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool WidevinePsshData::has_key_sequence() const {
  return _internal_has_key_sequence();
}
inline void WidevinePsshData::clear_key_sequence() {
  key_sequence_ = 0u;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_key_sequence() const {
  return key_sequence_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::key_sequence() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.key_sequence)
  return _internal_key_sequence();
}
inline void WidevinePsshData::_internal_set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00001000u;
  key_sequence_ = value;
}
inline void WidevinePsshData::set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_key_sequence(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_sequence)
}

// repeated bytes group_ids = 13;
inline int WidevinePsshData::_internal_group_ids_size() const {
  return group_ids_.size();
}
inline int WidevinePsshData::group_ids_size() const {
  return _internal_group_ids_size();
}
inline void WidevinePsshData::clear_group_ids() {
  group_ids_.Clear();
}
inline std::string* WidevinePsshData::add_group_ids() {
  // @@protoc_insertion_point(field_add_mutable:video_widevine.WidevinePsshData.group_ids)
  return _internal_add_group_ids();
}
inline const std::string& WidevinePsshData::_internal_group_ids(int index) const {
  return group_ids_.Get(index);
}
inline const std::string& WidevinePsshData::group_ids(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.group_ids)
  return _internal_group_ids(index);
}
inline std::string* WidevinePsshData::mutable_group_ids(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.group_ids)
  return group_ids_.Mutable(index);
}
inline void WidevinePsshData::set_group_ids(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.group_ids)
  group_ids_.Mutable(index)->assign(value);
}
inline void WidevinePsshData::set_group_ids(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.group_ids)
  group_ids_.Mutable(index)->assign(std::move(value));
}
inline void WidevinePsshData::set_group_ids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  group_ids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.group_ids)
}
inline void WidevinePsshData::set_group_ids(int index, const void* value, size_t size) {
  group_ids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.group_ids)
}
inline std::string* WidevinePsshData::_internal_add_group_ids() {
  return group_ids_.Add();
}
inline void WidevinePsshData::add_group_ids(const std::string& value) {
  group_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.group_ids)
}
inline void WidevinePsshData::add_group_ids(std::string&& value) {
  group_ids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.group_ids)
}
inline void WidevinePsshData::add_group_ids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  group_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.WidevinePsshData.group_ids)
}
inline void WidevinePsshData::add_group_ids(const void* value, size_t size) {
  group_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.WidevinePsshData.group_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
WidevinePsshData::group_ids() const {
  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.group_ids)
  return group_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
WidevinePsshData::mutable_group_ids() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.group_ids)
  return &group_ids_;
}

// repeated .video_widevine.WidevinePsshData.EntitledKey entitled_keys = 14;
inline int WidevinePsshData::_internal_entitled_keys_size() const {
  return entitled_keys_.size();
}
inline int WidevinePsshData::entitled_keys_size() const {
  return _internal_entitled_keys_size();
}
inline void WidevinePsshData::clear_entitled_keys() {
  entitled_keys_.Clear();
}
inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::mutable_entitled_keys(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.entitled_keys)
  return entitled_keys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >*
WidevinePsshData::mutable_entitled_keys() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.entitled_keys)
  return &entitled_keys_;
}
inline const ::video_widevine::WidevinePsshData_EntitledKey& WidevinePsshData::_internal_entitled_keys(int index) const {
  return entitled_keys_.Get(index);
}
inline const ::video_widevine::WidevinePsshData_EntitledKey& WidevinePsshData::entitled_keys(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.entitled_keys)
  return _internal_entitled_keys(index);
}
inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::_internal_add_entitled_keys() {
  return entitled_keys_.Add();
}
inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::add_entitled_keys() {
  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.entitled_keys)
  return _internal_add_entitled_keys();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >&
WidevinePsshData::entitled_keys() const {
  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.entitled_keys)
  return entitled_keys_;
}

// optional string video_feature = 15;
inline bool WidevinePsshData::_internal_has_video_feature() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool WidevinePsshData::has_video_feature() const {
  return _internal_has_video_feature();
}
inline void WidevinePsshData::clear_video_feature() {
  video_feature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000020u;
}
inline const std::string& WidevinePsshData::video_feature() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.video_feature)
  return _internal_video_feature();
}
inline void WidevinePsshData::set_video_feature(const std::string& value) {
  _internal_set_video_feature(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.video_feature)
}
inline std::string* WidevinePsshData::mutable_video_feature() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.video_feature)
  return _internal_mutable_video_feature();
}
inline const std::string& WidevinePsshData::_internal_video_feature() const {
  return video_feature_.Get();
}
inline void WidevinePsshData::_internal_set_video_feature(const std::string& value) {
  _has_bits_[0] |= 0x00000020u;
  video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WidevinePsshData::set_video_feature(std::string&& value) {
  _has_bits_[0] |= 0x00000020u;
  video_feature_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.WidevinePsshData.video_feature)
}
inline void WidevinePsshData::set_video_feature(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000020u;
  video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.video_feature)
}
inline void WidevinePsshData::set_video_feature(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000020u;
  video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.video_feature)
}
inline std::string* WidevinePsshData::_internal_mutable_video_feature() {
  _has_bits_[0] |= 0x00000020u;
  return video_feature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData::release_video_feature() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.video_feature)
  if (!_internal_has_video_feature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000020u;
  return video_feature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WidevinePsshData::set_allocated_video_feature(std::string* video_feature) {
  if (video_feature != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  video_feature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), video_feature,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.video_feature)
}

// optional string audio_feature = 16;
inline bool WidevinePsshData::_internal_has_audio_feature() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool WidevinePsshData::has_audio_feature() const {
  return _internal_has_audio_feature();
}
inline void WidevinePsshData::clear_audio_feature() {
  audio_feature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000040u;
}
inline const std::string& WidevinePsshData::audio_feature() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.audio_feature)
  return _internal_audio_feature();
}
inline void WidevinePsshData::set_audio_feature(const std::string& value) {
  _internal_set_audio_feature(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.audio_feature)
}
inline std::string* WidevinePsshData::mutable_audio_feature() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.audio_feature)
  return _internal_mutable_audio_feature();
}
inline const std::string& WidevinePsshData::_internal_audio_feature() const {
  return audio_feature_.Get();
}
inline void WidevinePsshData::_internal_set_audio_feature(const std::string& value) {
  _has_bits_[0] |= 0x00000040u;
  audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WidevinePsshData::set_audio_feature(std::string&& value) {
  _has_bits_[0] |= 0x00000040u;
  audio_feature_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.WidevinePsshData.audio_feature)
}
inline void WidevinePsshData::set_audio_feature(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000040u;
  audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.audio_feature)
}
inline void WidevinePsshData::set_audio_feature(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000040u;
  audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.audio_feature)
}
inline std::string* WidevinePsshData::_internal_mutable_audio_feature() {
  _has_bits_[0] |= 0x00000040u;
  return audio_feature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData::release_audio_feature() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.audio_feature)
  if (!_internal_has_audio_feature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000040u;
  return audio_feature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WidevinePsshData::set_allocated_audio_feature(std::string* audio_feature) {
  if (audio_feature != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  audio_feature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), audio_feature,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.audio_feature)
}

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

// optional .video_widevine.WidevinePsshData.Algorithm algorithm = 1 [deprecated = true];
inline bool WidevinePsshData::_internal_has_algorithm() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool WidevinePsshData::has_algorithm() const {
  return _internal_has_algorithm();
}
inline void WidevinePsshData::clear_algorithm() {
  algorithm_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline ::video_widevine::WidevinePsshData_Algorithm WidevinePsshData::_internal_algorithm() const {
  return static_cast< ::video_widevine::WidevinePsshData_Algorithm >(algorithm_);
}
inline ::video_widevine::WidevinePsshData_Algorithm WidevinePsshData::algorithm() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.algorithm)
  return _internal_algorithm();
}
inline void WidevinePsshData::_internal_set_algorithm(::video_widevine::WidevinePsshData_Algorithm value) {
  assert(::video_widevine::WidevinePsshData_Algorithm_IsValid(value));
  _has_bits_[0] |= 0x00000080u;
  algorithm_ = value;
}
inline void WidevinePsshData::set_algorithm(::video_widevine::WidevinePsshData_Algorithm value) {
  _internal_set_algorithm(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.algorithm)
}

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

// optional string track_type = 5 [deprecated = true];
inline bool WidevinePsshData::_internal_has_track_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool WidevinePsshData::has_track_type() const {
  return _internal_has_track_type();
}
inline void WidevinePsshData::clear_track_type() {
  track_type_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& WidevinePsshData::track_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.track_type)
  return _internal_track_type();
}
inline void WidevinePsshData::set_track_type(const std::string& value) {
  _internal_set_track_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.track_type)
}
inline std::string* WidevinePsshData::mutable_track_type() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.track_type)
  return _internal_mutable_track_type();
}
inline const std::string& WidevinePsshData::_internal_track_type() const {
  return track_type_.Get();
}
inline void WidevinePsshData::_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 WidevinePsshData::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.WidevinePsshData.track_type)
}
inline void WidevinePsshData::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.WidevinePsshData.track_type)
}
inline void WidevinePsshData::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.WidevinePsshData.track_type)
}
inline std::string* WidevinePsshData::_internal_mutable_track_type() {
  _has_bits_[0] |= 0x00000004u;
  return track_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData::release_track_type() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.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 WidevinePsshData::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.WidevinePsshData.track_type)
}

// optional string policy = 6 [deprecated = true];
inline bool WidevinePsshData::_internal_has_policy() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool WidevinePsshData::has_policy() const {
  return _internal_has_policy();
}
inline void WidevinePsshData::clear_policy() {
  policy_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& WidevinePsshData::policy() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.policy)
  return _internal_policy();
}
inline void WidevinePsshData::set_policy(const std::string& value) {
  _internal_set_policy(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.policy)
}
inline std::string* WidevinePsshData::mutable_policy() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.policy)
  return _internal_mutable_policy();
}
inline const std::string& WidevinePsshData::_internal_policy() const {
  return policy_.Get();
}
inline void WidevinePsshData::_internal_set_policy(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WidevinePsshData::set_policy(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  policy_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.WidevinePsshData.policy)
}
inline void WidevinePsshData::set_policy(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.policy)
}
inline void WidevinePsshData::set_policy(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.policy)
}
inline std::string* WidevinePsshData::_internal_mutable_policy() {
  _has_bits_[0] |= 0x00000008u;
  return policy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData::release_policy() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.policy)
  if (!_internal_has_policy()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return policy_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WidevinePsshData::set_allocated_policy(std::string* policy) {
  if (policy != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  policy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.policy)
}

// optional bytes grouped_license = 8 [deprecated = true];
inline bool WidevinePsshData::_internal_has_grouped_license() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool WidevinePsshData::has_grouped_license() const {
  return _internal_has_grouped_license();
}
inline void WidevinePsshData::clear_grouped_license() {
  grouped_license_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& WidevinePsshData::grouped_license() const {
  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.grouped_license)
  return _internal_grouped_license();
}
inline void WidevinePsshData::set_grouped_license(const std::string& value) {
  _internal_set_grouped_license(value);
  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.grouped_license)
}
inline std::string* WidevinePsshData::mutable_grouped_license() {
  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.grouped_license)
  return _internal_mutable_grouped_license();
}
inline const std::string& WidevinePsshData::_internal_grouped_license() const {
  return grouped_license_.Get();
}
inline void WidevinePsshData::_internal_set_grouped_license(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  grouped_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void WidevinePsshData::set_grouped_license(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  grouped_license_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:video_widevine.WidevinePsshData.grouped_license)
}
inline void WidevinePsshData::set_grouped_license(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  grouped_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.grouped_license)
}
inline void WidevinePsshData::set_grouped_license(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000010u;
  grouped_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.grouped_license)
}
inline std::string* WidevinePsshData::_internal_mutable_grouped_license() {
  _has_bits_[0] |= 0x00000010u;
  return grouped_license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* WidevinePsshData::release_grouped_license() {
  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.grouped_license)
  if (!_internal_has_grouped_license()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return grouped_license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void WidevinePsshData::set_allocated_grouped_license(std::string* grouped_license) {
  if (grouped_license != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  grouped_license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), grouped_license,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.grouped_license)
}

#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::WidevinePsshData_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::WidevinePsshData_Type>() {
  return ::video_widevine::WidevinePsshData_Type_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::WidevinePsshData_Algorithm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::WidevinePsshData_Algorithm>() {
  return ::video_widevine::WidevinePsshData_Algorithm_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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