wvpl_license_sdk/centos/protos/public/license_protocol.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3017000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "protos/public/client_identification.pb.h"
#include "protos/public/drm_certificate.pb.h"
#include "protos/public/dtcp_usage.pb.h"
#include "protos/public/hash_algorithm.pb.h"
#include "protos/public/remote_attestation.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2flicense_5fprotocol_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_2flicense_5fprotocol_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[22]
    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_2flicense_5fprotocol_2eproto;
namespace video_widevine {
class License;
struct LicenseDefaultTypeInternal;
extern LicenseDefaultTypeInternal _License_default_instance_;
class LicenseCategorySpec;
struct LicenseCategorySpecDefaultTypeInternal;
extern LicenseCategorySpecDefaultTypeInternal _LicenseCategorySpec_default_instance_;
class LicenseError;
struct LicenseErrorDefaultTypeInternal;
extern LicenseErrorDefaultTypeInternal _LicenseError_default_instance_;
class LicenseIdentification;
struct LicenseIdentificationDefaultTypeInternal;
extern LicenseIdentificationDefaultTypeInternal _LicenseIdentification_default_instance_;
class LicenseRequest;
struct LicenseRequestDefaultTypeInternal;
extern LicenseRequestDefaultTypeInternal _LicenseRequest_default_instance_;
class LicenseRequest_ContentIdentification;
struct LicenseRequest_ContentIdentificationDefaultTypeInternal;
extern LicenseRequest_ContentIdentificationDefaultTypeInternal _LicenseRequest_ContentIdentification_default_instance_;
class LicenseRequest_ContentIdentification_ExistingLicense;
struct LicenseRequest_ContentIdentification_ExistingLicenseDefaultTypeInternal;
extern LicenseRequest_ContentIdentification_ExistingLicenseDefaultTypeInternal _LicenseRequest_ContentIdentification_ExistingLicense_default_instance_;
class LicenseRequest_ContentIdentification_InitData;
struct LicenseRequest_ContentIdentification_InitDataDefaultTypeInternal;
extern LicenseRequest_ContentIdentification_InitDataDefaultTypeInternal _LicenseRequest_ContentIdentification_InitData_default_instance_;
class LicenseRequest_ContentIdentification_WebmKeyId;
struct LicenseRequest_ContentIdentification_WebmKeyIdDefaultTypeInternal;
extern LicenseRequest_ContentIdentification_WebmKeyIdDefaultTypeInternal _LicenseRequest_ContentIdentification_WebmKeyId_default_instance_;
class LicenseRequest_ContentIdentification_WidevinePsshData;
struct LicenseRequest_ContentIdentification_WidevinePsshDataDefaultTypeInternal;
extern LicenseRequest_ContentIdentification_WidevinePsshDataDefaultTypeInternal _LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_;
class License_KeyContainer;
struct License_KeyContainerDefaultTypeInternal;
extern License_KeyContainerDefaultTypeInternal _License_KeyContainer_default_instance_;
class License_KeyContainer_KeyCategorySpec;
struct License_KeyContainer_KeyCategorySpecDefaultTypeInternal;
extern License_KeyContainer_KeyCategorySpecDefaultTypeInternal _License_KeyContainer_KeyCategorySpec_default_instance_;
class License_KeyContainer_KeyControl;
struct License_KeyContainer_KeyControlDefaultTypeInternal;
extern License_KeyContainer_KeyControlDefaultTypeInternal _License_KeyContainer_KeyControl_default_instance_;
class License_KeyContainer_OperatorSessionKeyPermissions;
struct License_KeyContainer_OperatorSessionKeyPermissionsDefaultTypeInternal;
extern License_KeyContainer_OperatorSessionKeyPermissionsDefaultTypeInternal _License_KeyContainer_OperatorSessionKeyPermissions_default_instance_;
class License_KeyContainer_OutputProtection;
struct License_KeyContainer_OutputProtectionDefaultTypeInternal;
extern License_KeyContainer_OutputProtectionDefaultTypeInternal _License_KeyContainer_OutputProtection_default_instance_;
class License_KeyContainer_VideoResolutionConstraint;
struct License_KeyContainer_VideoResolutionConstraintDefaultTypeInternal;
extern License_KeyContainer_VideoResolutionConstraintDefaultTypeInternal _License_KeyContainer_VideoResolutionConstraint_default_instance_;
class License_Policy;
struct License_PolicyDefaultTypeInternal;
extern License_PolicyDefaultTypeInternal _License_Policy_default_instance_;
class MetricData;
struct MetricDataDefaultTypeInternal;
extern MetricDataDefaultTypeInternal _MetricData_default_instance_;
class MetricData_TypeValue;
struct MetricData_TypeValueDefaultTypeInternal;
extern MetricData_TypeValueDefaultTypeInternal _MetricData_TypeValue_default_instance_;
class ProxyInfo;
struct ProxyInfoDefaultTypeInternal;
extern ProxyInfoDefaultTypeInternal _ProxyInfo_default_instance_;
class SignedMessage;
struct SignedMessageDefaultTypeInternal;
extern SignedMessageDefaultTypeInternal _SignedMessage_default_instance_;
class VersionInfo;
struct VersionInfoDefaultTypeInternal;
extern VersionInfoDefaultTypeInternal _VersionInfo_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::License* Arena::CreateMaybeMessage<::video_widevine::License>(Arena*);
template<> ::video_widevine::LicenseCategorySpec* Arena::CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(Arena*);
template<> ::video_widevine::LicenseError* Arena::CreateMaybeMessage<::video_widevine::LicenseError>(Arena*);
template<> ::video_widevine::LicenseIdentification* Arena::CreateMaybeMessage<::video_widevine::LicenseIdentification>(Arena*);
template<> ::video_widevine::LicenseRequest* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest>(Arena*);
template<> ::video_widevine::LicenseRequest_ContentIdentification* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(Arena*);
template<> ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense>(Arena*);
template<> ::video_widevine::LicenseRequest_ContentIdentification_InitData* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_InitData>(Arena*);
template<> ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId>(Arena*);
template<> ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData>(Arena*);
template<> ::video_widevine::License_KeyContainer* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer>(Arena*);
template<> ::video_widevine::License_KeyContainer_KeyCategorySpec* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyCategorySpec>(Arena*);
template<> ::video_widevine::License_KeyContainer_KeyControl* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyControl>(Arena*);
template<> ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>(Arena*);
template<> ::video_widevine::License_KeyContainer_OutputProtection* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(Arena*);
template<> ::video_widevine::License_KeyContainer_VideoResolutionConstraint* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_VideoResolutionConstraint>(Arena*);
template<> ::video_widevine::License_Policy* Arena::CreateMaybeMessage<::video_widevine::License_Policy>(Arena*);
template<> ::video_widevine::MetricData* Arena::CreateMaybeMessage<::video_widevine::MetricData>(Arena*);
template<> ::video_widevine::MetricData_TypeValue* Arena::CreateMaybeMessage<::video_widevine::MetricData_TypeValue>(Arena*);
template<> ::video_widevine::ProxyInfo* Arena::CreateMaybeMessage<::video_widevine::ProxyInfo>(Arena*);
template<> ::video_widevine::SignedMessage* Arena::CreateMaybeMessage<::video_widevine::SignedMessage>(Arena*);
template<> ::video_widevine::VersionInfo* Arena::CreateMaybeMessage<::video_widevine::VersionInfo>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum LicenseCategorySpec_LicenseCategory : int {
  LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT = 0,
  LicenseCategorySpec_LicenseCategory_MULTI_CONTENT_LICENSE = 1,
  LicenseCategorySpec_LicenseCategory_GROUP_LICENSE = 2
};
bool LicenseCategorySpec_LicenseCategory_IsValid(int value);
constexpr LicenseCategorySpec_LicenseCategory LicenseCategorySpec_LicenseCategory_LicenseCategory_MIN = LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT;
constexpr LicenseCategorySpec_LicenseCategory LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX = LicenseCategorySpec_LicenseCategory_GROUP_LICENSE;
constexpr int LicenseCategorySpec_LicenseCategory_LicenseCategory_ARRAYSIZE = LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseCategorySpec_LicenseCategory_descriptor();
template<typename T>
inline const std::string& LicenseCategorySpec_LicenseCategory_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LicenseCategorySpec_LicenseCategory>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LicenseCategorySpec_LicenseCategory_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LicenseCategorySpec_LicenseCategory_descriptor(), enum_t_value);
}
inline bool LicenseCategorySpec_LicenseCategory_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseCategorySpec_LicenseCategory* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseCategorySpec_LicenseCategory>(
    LicenseCategorySpec_LicenseCategory_descriptor(), name, value);
}
enum License_Policy_WatermarkingControl : int {
  License_Policy_WatermarkingControl_WATERMARKING_CONTROL_UNSPECIFIED = 0,
  License_Policy_WatermarkingControl_WATERMARKING_FORBIDDEN = 1,
  License_Policy_WatermarkingControl_WATERMARKING_REQUIRED = 2
};
bool License_Policy_WatermarkingControl_IsValid(int value);
constexpr License_Policy_WatermarkingControl License_Policy_WatermarkingControl_WatermarkingControl_MIN = License_Policy_WatermarkingControl_WATERMARKING_CONTROL_UNSPECIFIED;
constexpr License_Policy_WatermarkingControl License_Policy_WatermarkingControl_WatermarkingControl_MAX = License_Policy_WatermarkingControl_WATERMARKING_REQUIRED;
constexpr int License_Policy_WatermarkingControl_WatermarkingControl_ARRAYSIZE = License_Policy_WatermarkingControl_WatermarkingControl_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_Policy_WatermarkingControl_descriptor();
template<typename T>
inline const std::string& License_Policy_WatermarkingControl_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_Policy_WatermarkingControl>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_Policy_WatermarkingControl_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_Policy_WatermarkingControl_descriptor(), enum_t_value);
}
inline bool License_Policy_WatermarkingControl_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_Policy_WatermarkingControl* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_Policy_WatermarkingControl>(
    License_Policy_WatermarkingControl_descriptor(), name, value);
}
enum License_KeyContainer_OutputProtection_HDCP : int {
  License_KeyContainer_OutputProtection_HDCP_HDCP_NONE = 0,
  License_KeyContainer_OutputProtection_HDCP_HDCP_V1 = 1,
  License_KeyContainer_OutputProtection_HDCP_HDCP_V2 = 2,
  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_1 = 3,
  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_2 = 4,
  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_3 = 5,
  License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT = 255
};
bool License_KeyContainer_OutputProtection_HDCP_IsValid(int value);
constexpr License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection_HDCP_HDCP_MIN = License_KeyContainer_OutputProtection_HDCP_HDCP_NONE;
constexpr License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection_HDCP_HDCP_MAX = License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT;
constexpr int License_KeyContainer_OutputProtection_HDCP_HDCP_ARRAYSIZE = License_KeyContainer_OutputProtection_HDCP_HDCP_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_HDCP_descriptor();
template<typename T>
inline const std::string& License_KeyContainer_OutputProtection_HDCP_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_HDCP>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_KeyContainer_OutputProtection_HDCP_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_KeyContainer_OutputProtection_HDCP_descriptor(), enum_t_value);
}
inline bool License_KeyContainer_OutputProtection_HDCP_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_HDCP* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_HDCP>(
    License_KeyContainer_OutputProtection_HDCP_descriptor(), name, value);
}
enum License_KeyContainer_OutputProtection_CGMS : int {
  License_KeyContainer_OutputProtection_CGMS_CGMS_NONE = 42,
  License_KeyContainer_OutputProtection_CGMS_COPY_FREE = 0,
  License_KeyContainer_OutputProtection_CGMS_COPY_ONCE = 2,
  License_KeyContainer_OutputProtection_CGMS_COPY_NEVER = 3
};
bool License_KeyContainer_OutputProtection_CGMS_IsValid(int value);
constexpr License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection_CGMS_CGMS_MIN = License_KeyContainer_OutputProtection_CGMS_COPY_FREE;
constexpr License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection_CGMS_CGMS_MAX = License_KeyContainer_OutputProtection_CGMS_CGMS_NONE;
constexpr int License_KeyContainer_OutputProtection_CGMS_CGMS_ARRAYSIZE = License_KeyContainer_OutputProtection_CGMS_CGMS_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_CGMS_descriptor();
template<typename T>
inline const std::string& License_KeyContainer_OutputProtection_CGMS_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_CGMS>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_KeyContainer_OutputProtection_CGMS_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_KeyContainer_OutputProtection_CGMS_descriptor(), enum_t_value);
}
inline bool License_KeyContainer_OutputProtection_CGMS_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_CGMS* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_CGMS>(
    License_KeyContainer_OutputProtection_CGMS_descriptor(), name, value);
}
enum License_KeyContainer_OutputProtection_HdcpSrmRule : int {
  License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE = 0,
  License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM = 1
};
bool License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(int value);
constexpr License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MIN = License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE;
constexpr License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX = License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM;
constexpr int License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_ARRAYSIZE = License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
template<typename T>
inline const std::string& License_KeyContainer_OutputProtection_HdcpSrmRule_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_HdcpSrmRule>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_KeyContainer_OutputProtection_HdcpSrmRule_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor(), enum_t_value);
}
inline bool License_KeyContainer_OutputProtection_HdcpSrmRule_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_HdcpSrmRule* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_HdcpSrmRule>(
    License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor(), name, value);
}
enum License_KeyContainer_KeyCategorySpec_KeyCategory : int {
  License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT = 0,
  License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY = 1
};
bool License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(int value);
constexpr License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MIN = License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT;
constexpr License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX = License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY;
constexpr int License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_ARRAYSIZE = License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
template<typename T>
inline const std::string& License_KeyContainer_KeyCategorySpec_KeyCategory_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_KeyContainer_KeyCategorySpec_KeyCategory>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_KeyContainer_KeyCategorySpec_KeyCategory_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor(), enum_t_value);
}
inline bool License_KeyContainer_KeyCategorySpec_KeyCategory_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_KeyCategorySpec_KeyCategory* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_KeyCategorySpec_KeyCategory>(
    License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor(), name, value);
}
enum License_KeyContainer_KeyType : int {
  License_KeyContainer_KeyType_SIGNING = 1,
  License_KeyContainer_KeyType_CONTENT = 2,
  License_KeyContainer_KeyType_KEY_CONTROL = 3,
  License_KeyContainer_KeyType_OPERATOR_SESSION = 4,
  License_KeyContainer_KeyType_ENTITLEMENT = 5,
  License_KeyContainer_KeyType_OEM_CONTENT = 6,
  License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY = 7,
  License_KeyContainer_KeyType_OEM_ENTITLEMENT = 8
};
bool License_KeyContainer_KeyType_IsValid(int value);
constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MIN = License_KeyContainer_KeyType_SIGNING;
constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MAX = License_KeyContainer_KeyType_OEM_ENTITLEMENT;
constexpr int License_KeyContainer_KeyType_KeyType_ARRAYSIZE = License_KeyContainer_KeyType_KeyType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyType_descriptor();
template<typename T>
inline const std::string& License_KeyContainer_KeyType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_KeyContainer_KeyType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_KeyContainer_KeyType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_KeyContainer_KeyType_descriptor(), enum_t_value);
}
inline bool License_KeyContainer_KeyType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_KeyType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_KeyType>(
    License_KeyContainer_KeyType_descriptor(), name, value);
}
enum License_KeyContainer_SecurityLevel : int {
  License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO = 1,
  License_KeyContainer_SecurityLevel_SW_SECURE_DECODE = 2,
  License_KeyContainer_SecurityLevel_HW_SECURE_CRYPTO = 3,
  License_KeyContainer_SecurityLevel_HW_SECURE_DECODE = 4,
  License_KeyContainer_SecurityLevel_HW_SECURE_ALL = 5
};
bool License_KeyContainer_SecurityLevel_IsValid(int value);
constexpr License_KeyContainer_SecurityLevel License_KeyContainer_SecurityLevel_SecurityLevel_MIN = License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO;
constexpr License_KeyContainer_SecurityLevel License_KeyContainer_SecurityLevel_SecurityLevel_MAX = License_KeyContainer_SecurityLevel_HW_SECURE_ALL;
constexpr int License_KeyContainer_SecurityLevel_SecurityLevel_ARRAYSIZE = License_KeyContainer_SecurityLevel_SecurityLevel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_SecurityLevel_descriptor();
template<typename T>
inline const std::string& License_KeyContainer_SecurityLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, License_KeyContainer_SecurityLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function License_KeyContainer_SecurityLevel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    License_KeyContainer_SecurityLevel_descriptor(), enum_t_value);
}
inline bool License_KeyContainer_SecurityLevel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_SecurityLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_SecurityLevel>(
    License_KeyContainer_SecurityLevel_descriptor(), name, value);
}
enum LicenseRequest_ContentIdentification_InitData_InitDataType : int {
  LicenseRequest_ContentIdentification_InitData_InitDataType_CENC = 1,
  LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM = 2
};
bool LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(int value);
constexpr LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MIN = LicenseRequest_ContentIdentification_InitData_InitDataType_CENC;
constexpr LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX = LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM;
constexpr int LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_ARRAYSIZE = LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
template<typename T>
inline const std::string& LicenseRequest_ContentIdentification_InitData_InitDataType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LicenseRequest_ContentIdentification_InitData_InitDataType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LicenseRequest_ContentIdentification_InitData_InitDataType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor(), enum_t_value);
}
inline bool LicenseRequest_ContentIdentification_InitData_InitDataType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseRequest_ContentIdentification_InitData_InitDataType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseRequest_ContentIdentification_InitData_InitDataType>(
    LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor(), name, value);
}
enum LicenseRequest_RequestType : int {
  LicenseRequest_RequestType_NEW = 1,
  LicenseRequest_RequestType_RENEWAL = 2,
  LicenseRequest_RequestType_RELEASE = 3
};
bool LicenseRequest_RequestType_IsValid(int value);
constexpr LicenseRequest_RequestType LicenseRequest_RequestType_RequestType_MIN = LicenseRequest_RequestType_NEW;
constexpr LicenseRequest_RequestType LicenseRequest_RequestType_RequestType_MAX = LicenseRequest_RequestType_RELEASE;
constexpr int LicenseRequest_RequestType_RequestType_ARRAYSIZE = LicenseRequest_RequestType_RequestType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseRequest_RequestType_descriptor();
template<typename T>
inline const std::string& LicenseRequest_RequestType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LicenseRequest_RequestType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LicenseRequest_RequestType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LicenseRequest_RequestType_descriptor(), enum_t_value);
}
inline bool LicenseRequest_RequestType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseRequest_RequestType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseRequest_RequestType>(
    LicenseRequest_RequestType_descriptor(), name, value);
}
enum LicenseError_Error : int {
  LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE = 1,
  LicenseError_Error_REVOKED_DRM_DEVICE_CERTIFICATE = 2,
  LicenseError_Error_SERVICE_UNAVAILABLE = 3,
  LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE = 4
};
bool LicenseError_Error_IsValid(int value);
constexpr LicenseError_Error LicenseError_Error_Error_MIN = LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE;
constexpr LicenseError_Error LicenseError_Error_Error_MAX = LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE;
constexpr int LicenseError_Error_Error_ARRAYSIZE = LicenseError_Error_Error_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseError_Error_descriptor();
template<typename T>
inline const std::string& LicenseError_Error_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LicenseError_Error>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LicenseError_Error_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LicenseError_Error_descriptor(), enum_t_value);
}
inline bool LicenseError_Error_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseError_Error* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseError_Error>(
    LicenseError_Error_descriptor(), name, value);
}
enum MetricData_MetricType : int {
  MetricData_MetricType_LATENCY = 1,
  MetricData_MetricType_TIMESTAMP = 2
};
bool MetricData_MetricType_IsValid(int value);
constexpr MetricData_MetricType MetricData_MetricType_MetricType_MIN = MetricData_MetricType_LATENCY;
constexpr MetricData_MetricType MetricData_MetricType_MetricType_MAX = MetricData_MetricType_TIMESTAMP;
constexpr int MetricData_MetricType_MetricType_ARRAYSIZE = MetricData_MetricType_MetricType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MetricData_MetricType_descriptor();
template<typename T>
inline const std::string& MetricData_MetricType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MetricData_MetricType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MetricData_MetricType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MetricData_MetricType_descriptor(), enum_t_value);
}
inline bool MetricData_MetricType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MetricData_MetricType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MetricData_MetricType>(
    MetricData_MetricType_descriptor(), name, value);
}
enum SignedMessage_MessageType : int {
  SignedMessage_MessageType_LICENSE_REQUEST = 1,
  SignedMessage_MessageType_LICENSE = 2,
  SignedMessage_MessageType_ERROR_RESPONSE = 3,
  SignedMessage_MessageType_SERVICE_CERTIFICATE_REQUEST = 4,
  SignedMessage_MessageType_SERVICE_CERTIFICATE = 5,
  SignedMessage_MessageType_SUB_LICENSE = 6,
  SignedMessage_MessageType_CAS_LICENSE_REQUEST = 7,
  SignedMessage_MessageType_CAS_LICENSE = 8,
  SignedMessage_MessageType_EXTERNAL_LICENSE_REQUEST = 9,
  SignedMessage_MessageType_EXTERNAL_LICENSE = 10
};
bool SignedMessage_MessageType_IsValid(int value);
constexpr SignedMessage_MessageType SignedMessage_MessageType_MessageType_MIN = SignedMessage_MessageType_LICENSE_REQUEST;
constexpr SignedMessage_MessageType SignedMessage_MessageType_MessageType_MAX = SignedMessage_MessageType_EXTERNAL_LICENSE;
constexpr int SignedMessage_MessageType_MessageType_ARRAYSIZE = SignedMessage_MessageType_MessageType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedMessage_MessageType_descriptor();
template<typename T>
inline const std::string& SignedMessage_MessageType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SignedMessage_MessageType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SignedMessage_MessageType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SignedMessage_MessageType_descriptor(), enum_t_value);
}
inline bool SignedMessage_MessageType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedMessage_MessageType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedMessage_MessageType>(
    SignedMessage_MessageType_descriptor(), name, value);
}
enum SignedMessage_SessionKeyType : int {
  SignedMessage_SessionKeyType_UNDEFINED = 0,
  SignedMessage_SessionKeyType_WRAPPED_AES_KEY = 1,
  SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY = 2
};
bool SignedMessage_SessionKeyType_IsValid(int value);
constexpr SignedMessage_SessionKeyType SignedMessage_SessionKeyType_SessionKeyType_MIN = SignedMessage_SessionKeyType_UNDEFINED;
constexpr SignedMessage_SessionKeyType SignedMessage_SessionKeyType_SessionKeyType_MAX = SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY;
constexpr int SignedMessage_SessionKeyType_SessionKeyType_ARRAYSIZE = SignedMessage_SessionKeyType_SessionKeyType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedMessage_SessionKeyType_descriptor();
template<typename T>
inline const std::string& SignedMessage_SessionKeyType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SignedMessage_SessionKeyType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SignedMessage_SessionKeyType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SignedMessage_SessionKeyType_descriptor(), enum_t_value);
}
inline bool SignedMessage_SessionKeyType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedMessage_SessionKeyType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedMessage_SessionKeyType>(
    SignedMessage_SessionKeyType_descriptor(), name, value);
}
enum LicenseType : int {
  STREAMING = 1,
  OFFLINE = 2,
  AUTOMATIC = 3
};
bool LicenseType_IsValid(int value);
constexpr LicenseType LicenseType_MIN = STREAMING;
constexpr LicenseType LicenseType_MAX = AUTOMATIC;
constexpr int LicenseType_ARRAYSIZE = LicenseType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseType_descriptor();
template<typename T>
inline const std::string& LicenseType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LicenseType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LicenseType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LicenseType_descriptor(), enum_t_value);
}
inline bool LicenseType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseType>(
    LicenseType_descriptor(), name, value);
}
enum PlatformVerificationStatus : int {
  PLATFORM_UNVERIFIED = 0,
  PLATFORM_TAMPERED = 1,
  PLATFORM_SOFTWARE_VERIFIED = 2,
  PLATFORM_HARDWARE_VERIFIED = 3,
  PLATFORM_NO_VERIFICATION = 4,
  PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED = 5
};
bool PlatformVerificationStatus_IsValid(int value);
constexpr PlatformVerificationStatus PlatformVerificationStatus_MIN = PLATFORM_UNVERIFIED;
constexpr PlatformVerificationStatus PlatformVerificationStatus_MAX = PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED;
constexpr int PlatformVerificationStatus_ARRAYSIZE = PlatformVerificationStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlatformVerificationStatus_descriptor();
template<typename T>
inline const std::string& PlatformVerificationStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PlatformVerificationStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PlatformVerificationStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PlatformVerificationStatus_descriptor(), enum_t_value);
}
inline bool PlatformVerificationStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlatformVerificationStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlatformVerificationStatus>(
    PlatformVerificationStatus_descriptor(), name, value);
}
enum ProtocolVersion : int {
  VERSION_2_0 = 20,
  VERSION_2_1 = 21,
  VERSION_2_2 = 22
};
bool ProtocolVersion_IsValid(int value);
constexpr ProtocolVersion ProtocolVersion_MIN = VERSION_2_0;
constexpr ProtocolVersion ProtocolVersion_MAX = VERSION_2_2;
constexpr int ProtocolVersion_ARRAYSIZE = ProtocolVersion_MAX + 1;

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

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

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

  inline LicenseIdentification& operator=(const LicenseIdentification& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseIdentification& operator=(LicenseIdentification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseIdentification& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseIdentification* internal_default_instance() {
    return reinterpret_cast<const LicenseIdentification*>(
               &_LicenseIdentification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  LicenseIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseIdentification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseIdentification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseIdentification& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseIdentification* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseIdentification";
  }
  protected:
  explicit LicenseIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRequestIdFieldNumber = 1,
    kSessionIdFieldNumber = 2,
    kPurchaseIdFieldNumber = 3,
    kProviderSessionTokenFieldNumber = 6,
    kOriginalRentalDurationSecondsFieldNumber = 7,
    kOriginalPlaybackDurationSecondsFieldNumber = 8,
    kOriginalStartTimeSecondsFieldNumber = 9,
    kOriginalRenewalRecoveryDurationSecondsFieldNumber = 10,
    kOriginalRenewalDelaySecondsFieldNumber = 11,
    kVersionFieldNumber = 5,
    kTypeFieldNumber = 4,
  };
  // optional bytes request_id = 1;
  bool has_request_id() const;
  private:
  bool _internal_has_request_id() const;
  public:
  void clear_request_id();
  const std::string& request_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_request_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_request_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
  void set_allocated_request_id(std::string* request_id);
  private:
  const std::string& _internal_request_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
  std::string* _internal_mutable_request_id();
  public:

  // optional bytes session_id = 2;
  bool has_session_id() const;
  private:
  bool _internal_has_session_id() const;
  public:
  void clear_session_id();
  const std::string& session_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_session_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_session_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
  void set_allocated_session_id(std::string* session_id);
  private:
  const std::string& _internal_session_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
  std::string* _internal_mutable_session_id();
  public:

  // optional bytes purchase_id = 3;
  bool has_purchase_id() const;
  private:
  bool _internal_has_purchase_id() const;
  public:
  void clear_purchase_id();
  const std::string& purchase_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_purchase_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_purchase_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_purchase_id();
  void set_allocated_purchase_id(std::string* purchase_id);
  private:
  const std::string& _internal_purchase_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purchase_id(const std::string& value);
  std::string* _internal_mutable_purchase_id();
  public:

  // optional bytes provider_session_token = 6;
  bool has_provider_session_token() const;
  private:
  bool _internal_has_provider_session_token() const;
  public:
  void clear_provider_session_token();
  const std::string& provider_session_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_provider_session_token();
  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
  void set_allocated_provider_session_token(std::string* provider_session_token);
  private:
  const std::string& _internal_provider_session_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
  std::string* _internal_mutable_provider_session_token();
  public:

  // optional int64 original_rental_duration_seconds = 7;
  bool has_original_rental_duration_seconds() const;
  private:
  bool _internal_has_original_rental_duration_seconds() const;
  public:
  void clear_original_rental_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds() const;
  void set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_rental_duration_seconds() const;
  void _internal_set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 original_playback_duration_seconds = 8;
  bool has_original_playback_duration_seconds() const;
  private:
  bool _internal_has_original_playback_duration_seconds() const;
  public:
  void clear_original_playback_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds() const;
  void set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_playback_duration_seconds() const;
  void _internal_set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 original_start_time_seconds = 9;
  bool has_original_start_time_seconds() const;
  private:
  bool _internal_has_original_start_time_seconds() const;
  public:
  void clear_original_start_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds() const;
  void set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_start_time_seconds() const;
  void _internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 original_renewal_recovery_duration_seconds = 10;
  bool has_original_renewal_recovery_duration_seconds() const;
  private:
  bool _internal_has_original_renewal_recovery_duration_seconds() const;
  public:
  void clear_original_renewal_recovery_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_recovery_duration_seconds() const;
  void set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_renewal_recovery_duration_seconds() const;
  void _internal_set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 original_renewal_delay_seconds = 11;
  bool has_original_renewal_delay_seconds() const;
  private:
  bool _internal_has_original_renewal_delay_seconds() const;
  public:
  void clear_original_renewal_delay_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_delay_seconds() const;
  void set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_renewal_delay_seconds() const;
  void _internal_set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int32 version = 5;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  ::PROTOBUF_NAMESPACE_ID::int32 version() const;
  void set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_version() const;
  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional .video_widevine.LicenseType type = 4;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::video_widevine::LicenseType type() const;
  void set_type(::video_widevine::LicenseType value);
  private:
  ::video_widevine::LicenseType _internal_type() const;
  void _internal_set_type(::video_widevine::LicenseType value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purchase_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_recovery_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_delay_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int32 version_;
  int type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseCategorySpec& operator=(const LicenseCategorySpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseCategorySpec& operator=(LicenseCategorySpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseCategorySpec& default_instance() {
    return *internal_default_instance();
  }
  enum ContentOrGroupIdCase {
    kContentId = 2,
    kGroupId = 3,
    CONTENT_OR_GROUP_ID_NOT_SET = 0,
  };

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

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

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

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

  LicenseCategorySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseCategorySpec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseCategorySpec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseCategorySpec& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseCategorySpec* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseCategorySpec";
  }
  protected:
  explicit LicenseCategorySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LicenseCategorySpec_LicenseCategory LicenseCategory;
  static constexpr LicenseCategory SINGLE_CONTENT_LICENSE_DEFAULT =
    LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT;
  static constexpr LicenseCategory MULTI_CONTENT_LICENSE =
    LicenseCategorySpec_LicenseCategory_MULTI_CONTENT_LICENSE;
  static constexpr LicenseCategory GROUP_LICENSE =
    LicenseCategorySpec_LicenseCategory_GROUP_LICENSE;
  static inline bool LicenseCategory_IsValid(int value) {
    return LicenseCategorySpec_LicenseCategory_IsValid(value);
  }
  static constexpr LicenseCategory LicenseCategory_MIN =
    LicenseCategorySpec_LicenseCategory_LicenseCategory_MIN;
  static constexpr LicenseCategory LicenseCategory_MAX =
    LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX;
  static constexpr int LicenseCategory_ARRAYSIZE =
    LicenseCategorySpec_LicenseCategory_LicenseCategory_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LicenseCategory_descriptor() {
    return LicenseCategorySpec_LicenseCategory_descriptor();
  }
  template<typename T>
  static inline const std::string& LicenseCategory_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LicenseCategory>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LicenseCategory_Name.");
    return LicenseCategorySpec_LicenseCategory_Name(enum_t_value);
  }
  static inline bool LicenseCategory_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      LicenseCategory* value) {
    return LicenseCategorySpec_LicenseCategory_Parse(name, value);
  }

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

  enum : int {
    kLicenseCategoryFieldNumber = 1,
    kContentIdFieldNumber = 2,
    kGroupIdFieldNumber = 3,
  };
  // optional .video_widevine.LicenseCategorySpec.LicenseCategory license_category = 1;
  bool has_license_category() const;
  private:
  bool _internal_has_license_category() const;
  public:
  void clear_license_category();
  ::video_widevine::LicenseCategorySpec_LicenseCategory license_category() const;
  void set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value);
  private:
  ::video_widevine::LicenseCategorySpec_LicenseCategory _internal_license_category() const;
  void _internal_set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value);
  public:

  // bytes content_id = 2;
  bool has_content_id() const;
  private:
  bool _internal_has_content_id() const;
  public:
  void clear_content_id();
  const std::string& content_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_content_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_content_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
  void set_allocated_content_id(std::string* content_id);
  private:
  const std::string& _internal_content_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
  std::string* _internal_mutable_content_id();
  public:

  // bytes group_id = 3;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  const std::string& group_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_group_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_group_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
  void set_allocated_group_id(std::string* group_id);
  private:
  const std::string& _internal_group_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
  std::string* _internal_mutable_group_id();
  public:

  void clear_content_or_group_id();
  ContentOrGroupIdCase content_or_group_id_case() const;
  // @@protoc_insertion_point(class_scope:video_widevine.LicenseCategorySpec)
 private:
  class _Internal;
  void set_has_content_id();
  void set_has_group_id();

  inline bool has_content_or_group_id() const;
  inline void clear_has_content_or_group_id();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int license_category_;
  union ContentOrGroupIdUnion {
    constexpr ContentOrGroupIdUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
  } content_or_group_id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ProxyInfo& operator=(const ProxyInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProxyInfo& operator=(ProxyInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ProxyInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProxyInfo* internal_default_instance() {
    return reinterpret_cast<const ProxyInfo*>(
               &_ProxyInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  ProxyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ProxyInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ProxyInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ProxyInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProxyInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.ProxyInfo";
  }
  protected:
  explicit ProxyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSdkVersionFieldNumber = 2,
    kSdkTypeFieldNumber = 1,
  };
  // optional string sdk_version = 2;
  bool has_sdk_version() const;
  private:
  bool _internal_has_sdk_version() const;
  public:
  void clear_sdk_version();
  const std::string& sdk_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdk_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdk_version();
  PROTOBUF_MUST_USE_RESULT std::string* release_sdk_version();
  void set_allocated_sdk_version(std::string* sdk_version);
  private:
  const std::string& _internal_sdk_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdk_version(const std::string& value);
  std::string* _internal_mutable_sdk_version();
  public:

  // optional .video_widevine.DrmCertificate.ServiceType sdk_type = 1;
  bool has_sdk_type() const;
  private:
  bool _internal_has_sdk_type() const;
  public:
  void clear_sdk_type();
  ::video_widevine::DrmCertificate_ServiceType sdk_type() const;
  void set_sdk_type(::video_widevine::DrmCertificate_ServiceType value);
  private:
  ::video_widevine::DrmCertificate_ServiceType _internal_sdk_type() const;
  void _internal_set_sdk_type(::video_widevine::DrmCertificate_ServiceType value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.ProxyInfo)
 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 sdk_version_;
  int sdk_type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_Policy& operator=(const License_Policy& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_Policy& operator=(License_Policy&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_Policy& default_instance() {
    return *internal_default_instance();
  }
  static inline const License_Policy* internal_default_instance() {
    return reinterpret_cast<const License_Policy*>(
               &_License_Policy_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

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

  License_Policy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_Policy>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_Policy& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_Policy& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_Policy* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.Policy";
  }
  protected:
  explicit License_Policy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef License_Policy_WatermarkingControl WatermarkingControl;
  static constexpr WatermarkingControl WATERMARKING_CONTROL_UNSPECIFIED =
    License_Policy_WatermarkingControl_WATERMARKING_CONTROL_UNSPECIFIED;
  static constexpr WatermarkingControl WATERMARKING_FORBIDDEN =
    License_Policy_WatermarkingControl_WATERMARKING_FORBIDDEN;
  static constexpr WatermarkingControl WATERMARKING_REQUIRED =
    License_Policy_WatermarkingControl_WATERMARKING_REQUIRED;
  static inline bool WatermarkingControl_IsValid(int value) {
    return License_Policy_WatermarkingControl_IsValid(value);
  }
  static constexpr WatermarkingControl WatermarkingControl_MIN =
    License_Policy_WatermarkingControl_WatermarkingControl_MIN;
  static constexpr WatermarkingControl WatermarkingControl_MAX =
    License_Policy_WatermarkingControl_WatermarkingControl_MAX;
  static constexpr int WatermarkingControl_ARRAYSIZE =
    License_Policy_WatermarkingControl_WatermarkingControl_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  WatermarkingControl_descriptor() {
    return License_Policy_WatermarkingControl_descriptor();
  }
  template<typename T>
  static inline const std::string& WatermarkingControl_Name(T enum_t_value) {
    static_assert(::std::is_same<T, WatermarkingControl>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function WatermarkingControl_Name.");
    return License_Policy_WatermarkingControl_Name(enum_t_value);
  }
  static inline bool WatermarkingControl_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      WatermarkingControl* value) {
    return License_Policy_WatermarkingControl_Parse(name, value);
  }

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

  enum : int {
    kRenewalServerUrlFieldNumber = 8,
    kDtcp2FieldNumber = 17,
    kRentalDurationSecondsFieldNumber = 4,
    kPlaybackDurationSecondsFieldNumber = 5,
    kLicenseDurationSecondsFieldNumber = 6,
    kRenewalRecoveryDurationSecondsFieldNumber = 7,
    kCanPlayFieldNumber = 1,
    kCanPersistFieldNumber = 2,
    kCanRenewFieldNumber = 3,
    kRenewWithUsageFieldNumber = 11,
    kAlwaysIncludeClientIdFieldNumber = 12,
    kSoftEnforcePlaybackDurationFieldNumber = 14,
    kRenewalDelaySecondsFieldNumber = 9,
    kRenewalRetryIntervalSecondsFieldNumber = 10,
    kPlayStartGracePeriodSecondsFieldNumber = 13,
    kWatermarkingControlFieldNumber = 16,
    kSoftEnforceRentalDurationFieldNumber = 15,
  };
  // optional string renewal_server_url = 8;
  bool has_renewal_server_url() const;
  private:
  bool _internal_has_renewal_server_url() const;
  public:
  void clear_renewal_server_url();
  const std::string& renewal_server_url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_renewal_server_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_renewal_server_url();
  PROTOBUF_MUST_USE_RESULT std::string* release_renewal_server_url();
  void set_allocated_renewal_server_url(std::string* renewal_server_url);
  private:
  const std::string& _internal_renewal_server_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_renewal_server_url(const std::string& value);
  std::string* _internal_mutable_renewal_server_url();
  public:

  // optional .video_widevine.DTCPUsageRules dtcp2 = 17;
  bool has_dtcp2() const;
  private:
  bool _internal_has_dtcp2() const;
  public:
  void clear_dtcp2();
  const ::video_widevine::DTCPUsageRules& dtcp2() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::DTCPUsageRules* release_dtcp2();
  ::video_widevine::DTCPUsageRules* mutable_dtcp2();
  void set_allocated_dtcp2(::video_widevine::DTCPUsageRules* dtcp2);
  private:
  const ::video_widevine::DTCPUsageRules& _internal_dtcp2() const;
  ::video_widevine::DTCPUsageRules* _internal_mutable_dtcp2();
  public:
  void unsafe_arena_set_allocated_dtcp2(
      ::video_widevine::DTCPUsageRules* dtcp2);
  ::video_widevine::DTCPUsageRules* unsafe_arena_release_dtcp2();

  // optional int64 rental_duration_seconds = 4 [default = 0];
  bool has_rental_duration_seconds() const;
  private:
  bool _internal_has_rental_duration_seconds() const;
  public:
  void clear_rental_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds() const;
  void set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_rental_duration_seconds() const;
  void _internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 playback_duration_seconds = 5 [default = 0];
  bool has_playback_duration_seconds() const;
  private:
  bool _internal_has_playback_duration_seconds() const;
  public:
  void clear_playback_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds() const;
  void set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_playback_duration_seconds() const;
  void _internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 license_duration_seconds = 6 [default = 0];
  bool has_license_duration_seconds() const;
  private:
  bool _internal_has_license_duration_seconds() const;
  public:
  void clear_license_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds() const;
  void set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_duration_seconds() const;
  void _internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
  bool has_renewal_recovery_duration_seconds() const;
  private:
  bool _internal_has_renewal_recovery_duration_seconds() const;
  public:
  void clear_renewal_recovery_duration_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds() const;
  void set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_recovery_duration_seconds() const;
  void _internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional bool can_play = 1 [default = false];
  bool has_can_play() const;
  private:
  bool _internal_has_can_play() const;
  public:
  void clear_can_play();
  bool can_play() const;
  void set_can_play(bool value);
  private:
  bool _internal_can_play() const;
  void _internal_set_can_play(bool value);
  public:

  // optional bool can_persist = 2 [default = false];
  bool has_can_persist() const;
  private:
  bool _internal_has_can_persist() const;
  public:
  void clear_can_persist();
  bool can_persist() const;
  void set_can_persist(bool value);
  private:
  bool _internal_can_persist() const;
  void _internal_set_can_persist(bool value);
  public:

  // optional bool can_renew = 3 [default = false];
  bool has_can_renew() const;
  private:
  bool _internal_has_can_renew() const;
  public:
  void clear_can_renew();
  bool can_renew() const;
  void set_can_renew(bool value);
  private:
  bool _internal_can_renew() const;
  void _internal_set_can_renew(bool value);
  public:

  // optional bool renew_with_usage = 11 [default = false];
  bool has_renew_with_usage() const;
  private:
  bool _internal_has_renew_with_usage() const;
  public:
  void clear_renew_with_usage();
  bool renew_with_usage() const;
  void set_renew_with_usage(bool value);
  private:
  bool _internal_renew_with_usage() const;
  void _internal_set_renew_with_usage(bool value);
  public:

  // optional bool always_include_client_id = 12 [default = false];
  bool has_always_include_client_id() const;
  private:
  bool _internal_has_always_include_client_id() const;
  public:
  void clear_always_include_client_id();
  bool always_include_client_id() const;
  void set_always_include_client_id(bool value);
  private:
  bool _internal_always_include_client_id() const;
  void _internal_set_always_include_client_id(bool value);
  public:

  // optional bool soft_enforce_playback_duration = 14 [default = false];
  bool has_soft_enforce_playback_duration() const;
  private:
  bool _internal_has_soft_enforce_playback_duration() const;
  public:
  void clear_soft_enforce_playback_duration();
  bool soft_enforce_playback_duration() const;
  void set_soft_enforce_playback_duration(bool value);
  private:
  bool _internal_soft_enforce_playback_duration() const;
  void _internal_set_soft_enforce_playback_duration(bool value);
  public:

  // optional int64 renewal_delay_seconds = 9 [default = 0];
  bool has_renewal_delay_seconds() const;
  private:
  bool _internal_has_renewal_delay_seconds() const;
  public:
  void clear_renewal_delay_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds() const;
  void set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_delay_seconds() const;
  void _internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 renewal_retry_interval_seconds = 10 [default = 0];
  bool has_renewal_retry_interval_seconds() const;
  private:
  bool _internal_has_renewal_retry_interval_seconds() const;
  public:
  void clear_renewal_retry_interval_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds() const;
  void set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_retry_interval_seconds() const;
  void _internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 play_start_grace_period_seconds = 13 [default = 0];
  bool has_play_start_grace_period_seconds() const;
  private:
  bool _internal_has_play_start_grace_period_seconds() const;
  public:
  void clear_play_start_grace_period_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds() const;
  void set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_play_start_grace_period_seconds() const;
  void _internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional .video_widevine.License.Policy.WatermarkingControl watermarking_control = 16 [default = WATERMARKING_CONTROL_UNSPECIFIED];
  bool has_watermarking_control() const;
  private:
  bool _internal_has_watermarking_control() const;
  public:
  void clear_watermarking_control();
  ::video_widevine::License_Policy_WatermarkingControl watermarking_control() const;
  void set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value);
  private:
  ::video_widevine::License_Policy_WatermarkingControl _internal_watermarking_control() const;
  void _internal_set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value);
  public:

  // optional bool soft_enforce_rental_duration = 15 [default = true];
  bool has_soft_enforce_rental_duration() const;
  private:
  bool _internal_has_soft_enforce_rental_duration() const;
  public:
  void clear_soft_enforce_rental_duration();
  bool soft_enforce_rental_duration() const;
  void set_soft_enforce_rental_duration(bool value);
  private:
  bool _internal_soft_enforce_rental_duration() const;
  void _internal_set_soft_enforce_rental_duration(bool value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.License.Policy)
 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 renewal_server_url_;
  ::video_widevine::DTCPUsageRules* dtcp2_;
  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds_;
  bool can_play_;
  bool can_persist_;
  bool can_renew_;
  bool renew_with_usage_;
  bool always_include_client_id_;
  bool soft_enforce_playback_duration_;
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds_;
  int watermarking_control_;
  bool soft_enforce_rental_duration_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_KeyContainer_KeyControl& operator=(const License_KeyContainer_KeyControl& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_KeyContainer_KeyControl& operator=(License_KeyContainer_KeyControl&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_KeyContainer_KeyControl& default_instance() {
    return *internal_default_instance();
  }
  static inline const License_KeyContainer_KeyControl* internal_default_instance() {
    return reinterpret_cast<const License_KeyContainer_KeyControl*>(
               &_License_KeyContainer_KeyControl_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

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

  License_KeyContainer_KeyControl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_KeyContainer_KeyControl>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_KeyContainer_KeyControl& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_KeyContainer_KeyControl& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_KeyContainer_KeyControl* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.KeyContainer.KeyControl";
  }
  protected:
  explicit License_KeyContainer_KeyControl(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kKeyControlBlockFieldNumber = 1,
    kIvFieldNumber = 2,
  };
  // optional bytes key_control_block = 1;
  bool has_key_control_block() const;
  private:
  bool _internal_has_key_control_block() const;
  public:
  void clear_key_control_block();
  const std::string& key_control_block() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key_control_block(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key_control_block();
  PROTOBUF_MUST_USE_RESULT std::string* release_key_control_block();
  void set_allocated_key_control_block(std::string* key_control_block);
  private:
  const std::string& _internal_key_control_block() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_control_block(const std::string& value);
  std::string* _internal_mutable_key_control_block();
  public:

  // optional bytes iv = 2;
  bool has_iv() const;
  private:
  bool _internal_has_iv() const;
  public:
  void clear_iv();
  const std::string& iv() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_iv(ArgT0&& arg0, ArgT... args);
  std::string* mutable_iv();
  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
  void set_allocated_iv(std::string* iv);
  private:
  const std::string& _internal_iv() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
  std::string* _internal_mutable_iv();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.KeyControl)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_control_block_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_KeyContainer_OutputProtection& operator=(const License_KeyContainer_OutputProtection& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_KeyContainer_OutputProtection& operator=(License_KeyContainer_OutputProtection&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_KeyContainer_OutputProtection& default_instance() {
    return *internal_default_instance();
  }
  static inline const License_KeyContainer_OutputProtection* internal_default_instance() {
    return reinterpret_cast<const License_KeyContainer_OutputProtection*>(
               &_License_KeyContainer_OutputProtection_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

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

  License_KeyContainer_OutputProtection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_KeyContainer_OutputProtection>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_KeyContainer_OutputProtection& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_KeyContainer_OutputProtection& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_KeyContainer_OutputProtection* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.KeyContainer.OutputProtection";
  }
  protected:
  explicit License_KeyContainer_OutputProtection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef License_KeyContainer_OutputProtection_HDCP HDCP;
  static constexpr HDCP HDCP_NONE =
    License_KeyContainer_OutputProtection_HDCP_HDCP_NONE;
  static constexpr HDCP HDCP_V1 =
    License_KeyContainer_OutputProtection_HDCP_HDCP_V1;
  static constexpr HDCP HDCP_V2 =
    License_KeyContainer_OutputProtection_HDCP_HDCP_V2;
  static constexpr HDCP HDCP_V2_1 =
    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_1;
  static constexpr HDCP HDCP_V2_2 =
    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_2;
  static constexpr HDCP HDCP_V2_3 =
    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_3;
  static constexpr HDCP HDCP_NO_DIGITAL_OUTPUT =
    License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT;
  static inline bool HDCP_IsValid(int value) {
    return License_KeyContainer_OutputProtection_HDCP_IsValid(value);
  }
  static constexpr HDCP HDCP_MIN =
    License_KeyContainer_OutputProtection_HDCP_HDCP_MIN;
  static constexpr HDCP HDCP_MAX =
    License_KeyContainer_OutputProtection_HDCP_HDCP_MAX;
  static constexpr int HDCP_ARRAYSIZE =
    License_KeyContainer_OutputProtection_HDCP_HDCP_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HDCP_descriptor() {
    return License_KeyContainer_OutputProtection_HDCP_descriptor();
  }
  template<typename T>
  static inline const std::string& HDCP_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HDCP>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HDCP_Name.");
    return License_KeyContainer_OutputProtection_HDCP_Name(enum_t_value);
  }
  static inline bool HDCP_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HDCP* value) {
    return License_KeyContainer_OutputProtection_HDCP_Parse(name, value);
  }

  typedef License_KeyContainer_OutputProtection_CGMS CGMS;
  static constexpr CGMS CGMS_NONE =
    License_KeyContainer_OutputProtection_CGMS_CGMS_NONE;
  static constexpr CGMS COPY_FREE =
    License_KeyContainer_OutputProtection_CGMS_COPY_FREE;
  static constexpr CGMS COPY_ONCE =
    License_KeyContainer_OutputProtection_CGMS_COPY_ONCE;
  static constexpr CGMS COPY_NEVER =
    License_KeyContainer_OutputProtection_CGMS_COPY_NEVER;
  static inline bool CGMS_IsValid(int value) {
    return License_KeyContainer_OutputProtection_CGMS_IsValid(value);
  }
  static constexpr CGMS CGMS_MIN =
    License_KeyContainer_OutputProtection_CGMS_CGMS_MIN;
  static constexpr CGMS CGMS_MAX =
    License_KeyContainer_OutputProtection_CGMS_CGMS_MAX;
  static constexpr int CGMS_ARRAYSIZE =
    License_KeyContainer_OutputProtection_CGMS_CGMS_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  CGMS_descriptor() {
    return License_KeyContainer_OutputProtection_CGMS_descriptor();
  }
  template<typename T>
  static inline const std::string& CGMS_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CGMS>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CGMS_Name.");
    return License_KeyContainer_OutputProtection_CGMS_Name(enum_t_value);
  }
  static inline bool CGMS_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CGMS* value) {
    return License_KeyContainer_OutputProtection_CGMS_Parse(name, value);
  }

  typedef License_KeyContainer_OutputProtection_HdcpSrmRule HdcpSrmRule;
  static constexpr HdcpSrmRule HDCP_SRM_RULE_NONE =
    License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE;
  static constexpr HdcpSrmRule CURRENT_SRM =
    License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM;
  static inline bool HdcpSrmRule_IsValid(int value) {
    return License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(value);
  }
  static constexpr HdcpSrmRule HdcpSrmRule_MIN =
    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MIN;
  static constexpr HdcpSrmRule HdcpSrmRule_MAX =
    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX;
  static constexpr int HdcpSrmRule_ARRAYSIZE =
    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HdcpSrmRule_descriptor() {
    return License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
  }
  template<typename T>
  static inline const std::string& HdcpSrmRule_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HdcpSrmRule>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HdcpSrmRule_Name.");
    return License_KeyContainer_OutputProtection_HdcpSrmRule_Name(enum_t_value);
  }
  static inline bool HdcpSrmRule_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HdcpSrmRule* value) {
    return License_KeyContainer_OutputProtection_HdcpSrmRule_Parse(name, value);
  }

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

  enum : int {
    kHdcpFieldNumber = 1,
    kHdcpSrmRuleFieldNumber = 3,
    kDisableAnalogOutputFieldNumber = 4,
    kDisableDigitalOutputFieldNumber = 5,
    kAllowRecordFieldNumber = 6,
    kCgmsFlagsFieldNumber = 2,
  };
  // optional .video_widevine.License.KeyContainer.OutputProtection.HDCP hdcp = 1 [default = HDCP_NONE];
  bool has_hdcp() const;
  private:
  bool _internal_has_hdcp() const;
  public:
  void clear_hdcp();
  ::video_widevine::License_KeyContainer_OutputProtection_HDCP hdcp() const;
  void set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value);
  private:
  ::video_widevine::License_KeyContainer_OutputProtection_HDCP _internal_hdcp() const;
  void _internal_set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value);
  public:

  // optional .video_widevine.License.KeyContainer.OutputProtection.HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
  bool has_hdcp_srm_rule() const;
  private:
  bool _internal_has_hdcp_srm_rule() const;
  public:
  void clear_hdcp_srm_rule();
  ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule hdcp_srm_rule() const;
  void set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value);
  private:
  ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule _internal_hdcp_srm_rule() const;
  void _internal_set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value);
  public:

  // optional bool disable_analog_output = 4 [default = false];
  bool has_disable_analog_output() const;
  private:
  bool _internal_has_disable_analog_output() const;
  public:
  void clear_disable_analog_output();
  bool disable_analog_output() const;
  void set_disable_analog_output(bool value);
  private:
  bool _internal_disable_analog_output() const;
  void _internal_set_disable_analog_output(bool value);
  public:

  // optional bool disable_digital_output = 5 [default = false];
  bool has_disable_digital_output() const;
  private:
  bool _internal_has_disable_digital_output() const;
  public:
  void clear_disable_digital_output();
  bool disable_digital_output() const;
  void set_disable_digital_output(bool value);
  private:
  bool _internal_disable_digital_output() const;
  void _internal_set_disable_digital_output(bool value);
  public:

  // optional bool allow_record = 6 [default = false];
  bool has_allow_record() const;
  private:
  bool _internal_has_allow_record() const;
  public:
  void clear_allow_record();
  bool allow_record() const;
  void set_allow_record(bool value);
  private:
  bool _internal_allow_record() const;
  void _internal_set_allow_record(bool value);
  public:

  // optional .video_widevine.License.KeyContainer.OutputProtection.CGMS cgms_flags = 2 [default = CGMS_NONE];
  bool has_cgms_flags() const;
  private:
  bool _internal_has_cgms_flags() const;
  public:
  void clear_cgms_flags();
  ::video_widevine::License_KeyContainer_OutputProtection_CGMS cgms_flags() const;
  void set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value);
  private:
  ::video_widevine::License_KeyContainer_OutputProtection_CGMS _internal_cgms_flags() const;
  void _internal_set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.OutputProtection)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int hdcp_;
  int hdcp_srm_rule_;
  bool disable_analog_output_;
  bool disable_digital_output_;
  bool allow_record_;
  int cgms_flags_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_KeyContainer_VideoResolutionConstraint& operator=(const License_KeyContainer_VideoResolutionConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_KeyContainer_VideoResolutionConstraint& operator=(License_KeyContainer_VideoResolutionConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_KeyContainer_VideoResolutionConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const License_KeyContainer_VideoResolutionConstraint* internal_default_instance() {
    return reinterpret_cast<const License_KeyContainer_VideoResolutionConstraint*>(
               &_License_KeyContainer_VideoResolutionConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

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

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

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

  License_KeyContainer_VideoResolutionConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_KeyContainer_VideoResolutionConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_KeyContainer_VideoResolutionConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_KeyContainer_VideoResolutionConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_KeyContainer_VideoResolutionConstraint* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.KeyContainer.VideoResolutionConstraint";
  }
  protected:
  explicit License_KeyContainer_VideoResolutionConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRequiredProtectionFieldNumber = 3,
    kMinResolutionPixelsFieldNumber = 1,
    kMaxResolutionPixelsFieldNumber = 2,
  };
  // optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 3;
  bool has_required_protection() const;
  private:
  bool _internal_has_required_protection() const;
  public:
  void clear_required_protection();
  const ::video_widevine::License_KeyContainer_OutputProtection& required_protection() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_required_protection();
  ::video_widevine::License_KeyContainer_OutputProtection* mutable_required_protection();
  void set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection);
  private:
  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_required_protection() const;
  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_required_protection();
  public:
  void unsafe_arena_set_allocated_required_protection(
      ::video_widevine::License_KeyContainer_OutputProtection* required_protection);
  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_required_protection();

  // optional uint32 min_resolution_pixels = 1;
  bool has_min_resolution_pixels() const;
  private:
  bool _internal_has_min_resolution_pixels() const;
  public:
  void clear_min_resolution_pixels();
  ::PROTOBUF_NAMESPACE_ID::uint32 min_resolution_pixels() const;
  void set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_min_resolution_pixels() const;
  void _internal_set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional uint32 max_resolution_pixels = 2;
  bool has_max_resolution_pixels() const;
  private:
  bool _internal_has_max_resolution_pixels() const;
  public:
  void clear_max_resolution_pixels();
  ::PROTOBUF_NAMESPACE_ID::uint32 max_resolution_pixels() const;
  void set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_resolution_pixels() const;
  void _internal_set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.VideoResolutionConstraint)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::video_widevine::License_KeyContainer_OutputProtection* required_protection_;
  ::PROTOBUF_NAMESPACE_ID::uint32 min_resolution_pixels_;
  ::PROTOBUF_NAMESPACE_ID::uint32 max_resolution_pixels_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_KeyContainer_OperatorSessionKeyPermissions& operator=(const License_KeyContainer_OperatorSessionKeyPermissions& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_KeyContainer_OperatorSessionKeyPermissions& operator=(License_KeyContainer_OperatorSessionKeyPermissions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_KeyContainer_OperatorSessionKeyPermissions& default_instance() {
    return *internal_default_instance();
  }
  static inline const License_KeyContainer_OperatorSessionKeyPermissions* internal_default_instance() {
    return reinterpret_cast<const License_KeyContainer_OperatorSessionKeyPermissions*>(
               &_License_KeyContainer_OperatorSessionKeyPermissions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

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

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

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

  License_KeyContainer_OperatorSessionKeyPermissions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_KeyContainer_OperatorSessionKeyPermissions>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_KeyContainer_OperatorSessionKeyPermissions& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_KeyContainer_OperatorSessionKeyPermissions& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_KeyContainer_OperatorSessionKeyPermissions* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.KeyContainer.OperatorSessionKeyPermissions";
  }
  protected:
  explicit License_KeyContainer_OperatorSessionKeyPermissions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kAllowEncryptFieldNumber = 1,
    kAllowDecryptFieldNumber = 2,
    kAllowSignFieldNumber = 3,
    kAllowSignatureVerifyFieldNumber = 4,
  };
  // optional bool allow_encrypt = 1 [default = false];
  bool has_allow_encrypt() const;
  private:
  bool _internal_has_allow_encrypt() const;
  public:
  void clear_allow_encrypt();
  bool allow_encrypt() const;
  void set_allow_encrypt(bool value);
  private:
  bool _internal_allow_encrypt() const;
  void _internal_set_allow_encrypt(bool value);
  public:

  // optional bool allow_decrypt = 2 [default = false];
  bool has_allow_decrypt() const;
  private:
  bool _internal_has_allow_decrypt() const;
  public:
  void clear_allow_decrypt();
  bool allow_decrypt() const;
  void set_allow_decrypt(bool value);
  private:
  bool _internal_allow_decrypt() const;
  void _internal_set_allow_decrypt(bool value);
  public:

  // optional bool allow_sign = 3 [default = false];
  bool has_allow_sign() const;
  private:
  bool _internal_has_allow_sign() const;
  public:
  void clear_allow_sign();
  bool allow_sign() const;
  void set_allow_sign(bool value);
  private:
  bool _internal_allow_sign() const;
  void _internal_set_allow_sign(bool value);
  public:

  // optional bool allow_signature_verify = 4 [default = false];
  bool has_allow_signature_verify() const;
  private:
  bool _internal_has_allow_signature_verify() const;
  public:
  void clear_allow_signature_verify();
  bool allow_signature_verify() const;
  void set_allow_signature_verify(bool value);
  private:
  bool _internal_allow_signature_verify() const;
  void _internal_set_allow_signature_verify(bool value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions)
 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_;
  bool allow_encrypt_;
  bool allow_decrypt_;
  bool allow_sign_;
  bool allow_signature_verify_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_KeyContainer_KeyCategorySpec& operator=(const License_KeyContainer_KeyCategorySpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_KeyContainer_KeyCategorySpec& operator=(License_KeyContainer_KeyCategorySpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_KeyContainer_KeyCategorySpec& default_instance() {
    return *internal_default_instance();
  }
  enum ContentOrGroupIdCase {
    kContentId = 2,
    kGroupId = 3,
    CONTENT_OR_GROUP_ID_NOT_SET = 0,
  };

  static inline const License_KeyContainer_KeyCategorySpec* internal_default_instance() {
    return reinterpret_cast<const License_KeyContainer_KeyCategorySpec*>(
               &_License_KeyContainer_KeyCategorySpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

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

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

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

  License_KeyContainer_KeyCategorySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_KeyContainer_KeyCategorySpec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_KeyContainer_KeyCategorySpec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_KeyContainer_KeyCategorySpec& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_KeyContainer_KeyCategorySpec* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.KeyContainer.KeyCategorySpec";
  }
  protected:
  explicit License_KeyContainer_KeyCategorySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef License_KeyContainer_KeyCategorySpec_KeyCategory KeyCategory;
  static constexpr KeyCategory SINGLE_CONTENT_KEY_DEFAULT =
    License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT;
  static constexpr KeyCategory GROUP_KEY =
    License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY;
  static inline bool KeyCategory_IsValid(int value) {
    return License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(value);
  }
  static constexpr KeyCategory KeyCategory_MIN =
    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MIN;
  static constexpr KeyCategory KeyCategory_MAX =
    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX;
  static constexpr int KeyCategory_ARRAYSIZE =
    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  KeyCategory_descriptor() {
    return License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
  }
  template<typename T>
  static inline const std::string& KeyCategory_Name(T enum_t_value) {
    static_assert(::std::is_same<T, KeyCategory>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function KeyCategory_Name.");
    return License_KeyContainer_KeyCategorySpec_KeyCategory_Name(enum_t_value);
  }
  static inline bool KeyCategory_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      KeyCategory* value) {
    return License_KeyContainer_KeyCategorySpec_KeyCategory_Parse(name, value);
  }

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

  enum : int {
    kKeyCategoryFieldNumber = 1,
    kContentIdFieldNumber = 2,
    kGroupIdFieldNumber = 3,
  };
  // optional .video_widevine.License.KeyContainer.KeyCategorySpec.KeyCategory key_category = 1;
  bool has_key_category() const;
  private:
  bool _internal_has_key_category() const;
  public:
  void clear_key_category();
  ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory key_category() const;
  void set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value);
  private:
  ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory _internal_key_category() const;
  void _internal_set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value);
  public:

  // bytes content_id = 2;
  bool has_content_id() const;
  private:
  bool _internal_has_content_id() const;
  public:
  void clear_content_id();
  const std::string& content_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_content_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_content_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
  void set_allocated_content_id(std::string* content_id);
  private:
  const std::string& _internal_content_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
  std::string* _internal_mutable_content_id();
  public:

  // bytes group_id = 3;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  const std::string& group_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_group_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_group_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
  void set_allocated_group_id(std::string* group_id);
  private:
  const std::string& _internal_group_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
  std::string* _internal_mutable_group_id();
  public:

  void clear_content_or_group_id();
  ContentOrGroupIdCase content_or_group_id_case() const;
  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.KeyCategorySpec)
 private:
  class _Internal;
  void set_has_content_id();
  void set_has_group_id();

  inline bool has_content_or_group_id() const;
  inline void clear_has_content_or_group_id();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int key_category_;
  union ContentOrGroupIdUnion {
    constexpr ContentOrGroupIdUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
  } content_or_group_id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License_KeyContainer& operator=(const License_KeyContainer& from) {
    CopyFrom(from);
    return *this;
  }
  inline License_KeyContainer& operator=(License_KeyContainer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License_KeyContainer& default_instance() {
    return *internal_default_instance();
  }
  static inline const License_KeyContainer* internal_default_instance() {
    return reinterpret_cast<const License_KeyContainer*>(
               &_License_KeyContainer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

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

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

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

  License_KeyContainer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License_KeyContainer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License_KeyContainer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License_KeyContainer& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License_KeyContainer* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License.KeyContainer";
  }
  protected:
  explicit License_KeyContainer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef License_KeyContainer_KeyControl KeyControl;
  typedef License_KeyContainer_OutputProtection OutputProtection;
  typedef License_KeyContainer_VideoResolutionConstraint VideoResolutionConstraint;
  typedef License_KeyContainer_OperatorSessionKeyPermissions OperatorSessionKeyPermissions;
  typedef License_KeyContainer_KeyCategorySpec KeyCategorySpec;

  typedef License_KeyContainer_KeyType KeyType;
  static constexpr KeyType SIGNING =
    License_KeyContainer_KeyType_SIGNING;
  static constexpr KeyType CONTENT =
    License_KeyContainer_KeyType_CONTENT;
  static constexpr KeyType KEY_CONTROL =
    License_KeyContainer_KeyType_KEY_CONTROL;
  static constexpr KeyType OPERATOR_SESSION =
    License_KeyContainer_KeyType_OPERATOR_SESSION;
  static constexpr KeyType ENTITLEMENT =
    License_KeyContainer_KeyType_ENTITLEMENT;
  static constexpr KeyType OEM_CONTENT =
    License_KeyContainer_KeyType_OEM_CONTENT;
  static constexpr KeyType PROVIDER_ECM_VERIFIER_PUBLIC_KEY =
    License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
  static constexpr KeyType OEM_ENTITLEMENT =
    License_KeyContainer_KeyType_OEM_ENTITLEMENT;
  static inline bool KeyType_IsValid(int value) {
    return License_KeyContainer_KeyType_IsValid(value);
  }
  static constexpr KeyType KeyType_MIN =
    License_KeyContainer_KeyType_KeyType_MIN;
  static constexpr KeyType KeyType_MAX =
    License_KeyContainer_KeyType_KeyType_MAX;
  static constexpr int KeyType_ARRAYSIZE =
    License_KeyContainer_KeyType_KeyType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  KeyType_descriptor() {
    return License_KeyContainer_KeyType_descriptor();
  }
  template<typename T>
  static inline const std::string& KeyType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, KeyType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function KeyType_Name.");
    return License_KeyContainer_KeyType_Name(enum_t_value);
  }
  static inline bool KeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      KeyType* value) {
    return License_KeyContainer_KeyType_Parse(name, value);
  }

  typedef License_KeyContainer_SecurityLevel SecurityLevel;
  static constexpr SecurityLevel SW_SECURE_CRYPTO =
    License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO;
  static constexpr SecurityLevel SW_SECURE_DECODE =
    License_KeyContainer_SecurityLevel_SW_SECURE_DECODE;
  static constexpr SecurityLevel HW_SECURE_CRYPTO =
    License_KeyContainer_SecurityLevel_HW_SECURE_CRYPTO;
  static constexpr SecurityLevel HW_SECURE_DECODE =
    License_KeyContainer_SecurityLevel_HW_SECURE_DECODE;
  static constexpr SecurityLevel HW_SECURE_ALL =
    License_KeyContainer_SecurityLevel_HW_SECURE_ALL;
  static inline bool SecurityLevel_IsValid(int value) {
    return License_KeyContainer_SecurityLevel_IsValid(value);
  }
  static constexpr SecurityLevel SecurityLevel_MIN =
    License_KeyContainer_SecurityLevel_SecurityLevel_MIN;
  static constexpr SecurityLevel SecurityLevel_MAX =
    License_KeyContainer_SecurityLevel_SecurityLevel_MAX;
  static constexpr int SecurityLevel_ARRAYSIZE =
    License_KeyContainer_SecurityLevel_SecurityLevel_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SecurityLevel_descriptor() {
    return License_KeyContainer_SecurityLevel_descriptor();
  }
  template<typename T>
  static inline const std::string& SecurityLevel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SecurityLevel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SecurityLevel_Name.");
    return License_KeyContainer_SecurityLevel_Name(enum_t_value);
  }
  static inline bool SecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SecurityLevel* value) {
    return License_KeyContainer_SecurityLevel_Parse(name, value);
  }

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

  enum : int {
    kVideoResolutionConstraintsFieldNumber = 10,
    kIdFieldNumber = 1,
    kIvFieldNumber = 2,
    kKeyFieldNumber = 3,
    kTrackLabelFieldNumber = 12,
    kRequiredProtectionFieldNumber = 6,
    kRequestedProtectionFieldNumber = 7,
    kKeyControlFieldNumber = 8,
    kOperatorSessionKeyPermissionsFieldNumber = 9,
    kKeyCategorySpecFieldNumber = 13,
    kAntiRollbackUsageTableFieldNumber = 11,
    kTypeFieldNumber = 4,
    kLevelFieldNumber = 5,
  };
  // repeated .video_widevine.License.KeyContainer.VideoResolutionConstraint video_resolution_constraints = 10;
  int video_resolution_constraints_size() const;
  private:
  int _internal_video_resolution_constraints_size() const;
  public:
  void clear_video_resolution_constraints();
  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* mutable_video_resolution_constraints(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >*
      mutable_video_resolution_constraints();
  private:
  const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& _internal_video_resolution_constraints(int index) const;
  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* _internal_add_video_resolution_constraints();
  public:
  const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& video_resolution_constraints(int index) const;
  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* add_video_resolution_constraints();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >&
      video_resolution_constraints() const;

  // optional bytes id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional bytes iv = 2;
  bool has_iv() const;
  private:
  bool _internal_has_iv() const;
  public:
  void clear_iv();
  const std::string& iv() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_iv(ArgT0&& arg0, ArgT... args);
  std::string* mutable_iv();
  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
  void set_allocated_iv(std::string* iv);
  private:
  const std::string& _internal_iv() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
  std::string* _internal_mutable_iv();
  public:

  // optional bytes key = 3;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_MUST_USE_RESULT std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // optional string track_label = 12;
  bool has_track_label() const;
  private:
  bool _internal_has_track_label() const;
  public:
  void clear_track_label();
  const std::string& track_label() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_track_label(ArgT0&& arg0, ArgT... args);
  std::string* mutable_track_label();
  PROTOBUF_MUST_USE_RESULT std::string* release_track_label();
  void set_allocated_track_label(std::string* track_label);
  private:
  const std::string& _internal_track_label() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_track_label(const std::string& value);
  std::string* _internal_mutable_track_label();
  public:

  // optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 6;
  bool has_required_protection() const;
  private:
  bool _internal_has_required_protection() const;
  public:
  void clear_required_protection();
  const ::video_widevine::License_KeyContainer_OutputProtection& required_protection() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_required_protection();
  ::video_widevine::License_KeyContainer_OutputProtection* mutable_required_protection();
  void set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection);
  private:
  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_required_protection() const;
  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_required_protection();
  public:
  void unsafe_arena_set_allocated_required_protection(
      ::video_widevine::License_KeyContainer_OutputProtection* required_protection);
  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_required_protection();

  // optional .video_widevine.License.KeyContainer.OutputProtection requested_protection = 7;
  bool has_requested_protection() const;
  private:
  bool _internal_has_requested_protection() const;
  public:
  void clear_requested_protection();
  const ::video_widevine::License_KeyContainer_OutputProtection& requested_protection() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_requested_protection();
  ::video_widevine::License_KeyContainer_OutputProtection* mutable_requested_protection();
  void set_allocated_requested_protection(::video_widevine::License_KeyContainer_OutputProtection* requested_protection);
  private:
  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_requested_protection() const;
  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_requested_protection();
  public:
  void unsafe_arena_set_allocated_requested_protection(
      ::video_widevine::License_KeyContainer_OutputProtection* requested_protection);
  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_requested_protection();

  // optional .video_widevine.License.KeyContainer.KeyControl key_control = 8;
  bool has_key_control() const;
  private:
  bool _internal_has_key_control() const;
  public:
  void clear_key_control();
  const ::video_widevine::License_KeyContainer_KeyControl& key_control() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_KeyControl* release_key_control();
  ::video_widevine::License_KeyContainer_KeyControl* mutable_key_control();
  void set_allocated_key_control(::video_widevine::License_KeyContainer_KeyControl* key_control);
  private:
  const ::video_widevine::License_KeyContainer_KeyControl& _internal_key_control() const;
  ::video_widevine::License_KeyContainer_KeyControl* _internal_mutable_key_control();
  public:
  void unsafe_arena_set_allocated_key_control(
      ::video_widevine::License_KeyContainer_KeyControl* key_control);
  ::video_widevine::License_KeyContainer_KeyControl* unsafe_arena_release_key_control();

  // optional .video_widevine.License.KeyContainer.OperatorSessionKeyPermissions operator_session_key_permissions = 9;
  bool has_operator_session_key_permissions() const;
  private:
  bool _internal_has_operator_session_key_permissions() const;
  public:
  void clear_operator_session_key_permissions();
  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& operator_session_key_permissions() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* release_operator_session_key_permissions();
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* mutable_operator_session_key_permissions();
  void set_allocated_operator_session_key_permissions(::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions);
  private:
  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& _internal_operator_session_key_permissions() const;
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* _internal_mutable_operator_session_key_permissions();
  public:
  void unsafe_arena_set_allocated_operator_session_key_permissions(
      ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions);
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* unsafe_arena_release_operator_session_key_permissions();

  // optional .video_widevine.License.KeyContainer.KeyCategorySpec key_category_spec = 13;
  bool has_key_category_spec() const;
  private:
  bool _internal_has_key_category_spec() const;
  public:
  void clear_key_category_spec();
  const ::video_widevine::License_KeyContainer_KeyCategorySpec& key_category_spec() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_KeyCategorySpec* release_key_category_spec();
  ::video_widevine::License_KeyContainer_KeyCategorySpec* mutable_key_category_spec();
  void set_allocated_key_category_spec(::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec);
  private:
  const ::video_widevine::License_KeyContainer_KeyCategorySpec& _internal_key_category_spec() const;
  ::video_widevine::License_KeyContainer_KeyCategorySpec* _internal_mutable_key_category_spec();
  public:
  void unsafe_arena_set_allocated_key_category_spec(
      ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec);
  ::video_widevine::License_KeyContainer_KeyCategorySpec* unsafe_arena_release_key_category_spec();

  // optional bool anti_rollback_usage_table = 11 [default = false];
  bool has_anti_rollback_usage_table() const;
  private:
  bool _internal_has_anti_rollback_usage_table() const;
  public:
  void clear_anti_rollback_usage_table();
  bool anti_rollback_usage_table() const;
  void set_anti_rollback_usage_table(bool value);
  private:
  bool _internal_anti_rollback_usage_table() const;
  void _internal_set_anti_rollback_usage_table(bool value);
  public:

  // optional .video_widevine.License.KeyContainer.KeyType type = 4;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::video_widevine::License_KeyContainer_KeyType type() const;
  void set_type(::video_widevine::License_KeyContainer_KeyType value);
  private:
  ::video_widevine::License_KeyContainer_KeyType _internal_type() const;
  void _internal_set_type(::video_widevine::License_KeyContainer_KeyType value);
  public:

  // optional .video_widevine.License.KeyContainer.SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
  bool has_level() const;
  private:
  bool _internal_has_level() const;
  public:
  void clear_level();
  ::video_widevine::License_KeyContainer_SecurityLevel level() const;
  void set_level(::video_widevine::License_KeyContainer_SecurityLevel value);
  private:
  ::video_widevine::License_KeyContainer_SecurityLevel _internal_level() const;
  void _internal_set_level(::video_widevine::License_KeyContainer_SecurityLevel value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint > video_resolution_constraints_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_label_;
  ::video_widevine::License_KeyContainer_OutputProtection* required_protection_;
  ::video_widevine::License_KeyContainer_OutputProtection* requested_protection_;
  ::video_widevine::License_KeyContainer_KeyControl* key_control_;
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions_;
  ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec_;
  bool anti_rollback_usage_table_;
  int type_;
  int level_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline License& operator=(const License& from) {
    CopyFrom(from);
    return *this;
  }
  inline License& operator=(License&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const License& default_instance() {
    return *internal_default_instance();
  }
  static inline const License* internal_default_instance() {
    return reinterpret_cast<const License*>(
               &_License_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

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

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

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

  License* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<License>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const License& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const License& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(License* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.License";
  }
  protected:
  explicit License(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef License_Policy Policy;
  typedef License_KeyContainer KeyContainer;

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

  enum : int {
    kKeyFieldNumber = 3,
    kGroupIdsFieldNumber = 11,
    kProviderClientTokenFieldNumber = 6,
    kSrmRequirementFieldNumber = 8,
    kSrmUpdateFieldNumber = 9,
    kIdFieldNumber = 1,
    kPolicyFieldNumber = 2,
    kLicenseCategorySpecFieldNumber = 12,
    kLicenseStartTimeFieldNumber = 4,
    kRemoteAttestationVerifiedFieldNumber = 5,
    kProtectionSchemeFieldNumber = 7,
    kProviderKeyIdFieldNumber = 13,
    kPlatformVerificationStatusFieldNumber = 10,
  };
  // repeated .video_widevine.License.KeyContainer key = 3;
  int key_size() const;
  private:
  int _internal_key_size() const;
  public:
  void clear_key();
  ::video_widevine::License_KeyContainer* mutable_key(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >*
      mutable_key();
  private:
  const ::video_widevine::License_KeyContainer& _internal_key(int index) const;
  ::video_widevine::License_KeyContainer* _internal_add_key();
  public:
  const ::video_widevine::License_KeyContainer& key(int index) const;
  ::video_widevine::License_KeyContainer* add_key();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >&
      key() const;

  // repeated bytes group_ids = 11;
  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:

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

  // optional bytes srm_requirement = 8;
  bool has_srm_requirement() const;
  private:
  bool _internal_has_srm_requirement() const;
  public:
  void clear_srm_requirement();
  const std::string& srm_requirement() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_srm_requirement(ArgT0&& arg0, ArgT... args);
  std::string* mutable_srm_requirement();
  PROTOBUF_MUST_USE_RESULT std::string* release_srm_requirement();
  void set_allocated_srm_requirement(std::string* srm_requirement);
  private:
  const std::string& _internal_srm_requirement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_srm_requirement(const std::string& value);
  std::string* _internal_mutable_srm_requirement();
  public:

  // optional bytes srm_update = 9;
  bool has_srm_update() const;
  private:
  bool _internal_has_srm_update() const;
  public:
  void clear_srm_update();
  const std::string& srm_update() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_srm_update(ArgT0&& arg0, ArgT... args);
  std::string* mutable_srm_update();
  PROTOBUF_MUST_USE_RESULT std::string* release_srm_update();
  void set_allocated_srm_update(std::string* srm_update);
  private:
  const std::string& _internal_srm_update() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_srm_update(const std::string& value);
  std::string* _internal_mutable_srm_update();
  public:

  // optional .video_widevine.LicenseIdentification id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const ::video_widevine::LicenseIdentification& id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_id();
  ::video_widevine::LicenseIdentification* mutable_id();
  void set_allocated_id(::video_widevine::LicenseIdentification* id);
  private:
  const ::video_widevine::LicenseIdentification& _internal_id() const;
  ::video_widevine::LicenseIdentification* _internal_mutable_id();
  public:
  void unsafe_arena_set_allocated_id(
      ::video_widevine::LicenseIdentification* id);
  ::video_widevine::LicenseIdentification* unsafe_arena_release_id();

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

  // optional .video_widevine.LicenseCategorySpec license_category_spec = 12;
  bool has_license_category_spec() const;
  private:
  bool _internal_has_license_category_spec() const;
  public:
  void clear_license_category_spec();
  const ::video_widevine::LicenseCategorySpec& license_category_spec() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseCategorySpec* release_license_category_spec();
  ::video_widevine::LicenseCategorySpec* mutable_license_category_spec();
  void set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec);
  private:
  const ::video_widevine::LicenseCategorySpec& _internal_license_category_spec() const;
  ::video_widevine::LicenseCategorySpec* _internal_mutable_license_category_spec();
  public:
  void unsafe_arena_set_allocated_license_category_spec(
      ::video_widevine::LicenseCategorySpec* license_category_spec);
  ::video_widevine::LicenseCategorySpec* unsafe_arena_release_license_category_spec();

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

  // optional bool remote_attestation_verified = 5 [default = false];
  bool has_remote_attestation_verified() const;
  private:
  bool _internal_has_remote_attestation_verified() const;
  public:
  void clear_remote_attestation_verified();
  bool remote_attestation_verified() const;
  void set_remote_attestation_verified(bool value);
  private:
  bool _internal_remote_attestation_verified() const;
  void _internal_set_remote_attestation_verified(bool value);
  public:

  // optional uint32 protection_scheme = 7;
  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 provider_key_id = 13;
  bool has_provider_key_id() const;
  private:
  bool _internal_has_provider_key_id() const;
  public:
  void clear_provider_key_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 provider_key_id() const;
  void set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_provider_key_id() const;
  void _internal_set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
  bool has_platform_verification_status() const;
  private:
  bool _internal_has_platform_verification_status() const;
  public:
  void clear_platform_verification_status();
  ::video_widevine::PlatformVerificationStatus platform_verification_status() const;
  void set_platform_verification_status(::video_widevine::PlatformVerificationStatus value);
  private:
  ::video_widevine::PlatformVerificationStatus _internal_platform_verification_status() const;
  void _internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer > key_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> group_ids_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr srm_requirement_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr srm_update_;
  ::video_widevine::LicenseIdentification* id_;
  ::video_widevine::License_Policy* policy_;
  ::video_widevine::LicenseCategorySpec* license_category_spec_;
  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
  bool remote_attestation_verified_;
  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
  ::PROTOBUF_NAMESPACE_ID::uint32 provider_key_id_;
  int platform_verification_status_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseRequest_ContentIdentification_WidevinePsshData& operator=(const LicenseRequest_ContentIdentification_WidevinePsshData& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseRequest_ContentIdentification_WidevinePsshData& operator=(LicenseRequest_ContentIdentification_WidevinePsshData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseRequest_ContentIdentification_WidevinePsshData& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseRequest_ContentIdentification_WidevinePsshData* internal_default_instance() {
    return reinterpret_cast<const LicenseRequest_ContentIdentification_WidevinePsshData*>(
               &_LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

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

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

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

  LicenseRequest_ContentIdentification_WidevinePsshData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseRequest_ContentIdentification_WidevinePsshData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseRequest_ContentIdentification_WidevinePsshData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData";
  }
  protected:
  explicit LicenseRequest_ContentIdentification_WidevinePsshData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPsshDataFieldNumber = 1,
    kRequestIdFieldNumber = 3,
    kLicenseTypeFieldNumber = 2,
  };
  // repeated bytes pssh_data = 1;
  int pssh_data_size() const;
  private:
  int _internal_pssh_data_size() const;
  public:
  void clear_pssh_data();
  const std::string& pssh_data(int index) const;
  std::string* mutable_pssh_data(int index);
  void set_pssh_data(int index, const std::string& value);
  void set_pssh_data(int index, std::string&& value);
  void set_pssh_data(int index, const char* value);
  void set_pssh_data(int index, const void* value, size_t size);
  std::string* add_pssh_data();
  void add_pssh_data(const std::string& value);
  void add_pssh_data(std::string&& value);
  void add_pssh_data(const char* value);
  void add_pssh_data(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& pssh_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_pssh_data();
  private:
  const std::string& _internal_pssh_data(int index) const;
  std::string* _internal_add_pssh_data();
  public:

  // optional bytes request_id = 3;
  bool has_request_id() const;
  private:
  bool _internal_has_request_id() const;
  public:
  void clear_request_id();
  const std::string& request_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_request_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_request_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
  void set_allocated_request_id(std::string* request_id);
  private:
  const std::string& _internal_request_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
  std::string* _internal_mutable_request_id();
  public:

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

  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.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> pssh_data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
  int license_type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseRequest_ContentIdentification_WebmKeyId& operator=(const LicenseRequest_ContentIdentification_WebmKeyId& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseRequest_ContentIdentification_WebmKeyId& operator=(LicenseRequest_ContentIdentification_WebmKeyId&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseRequest_ContentIdentification_WebmKeyId& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseRequest_ContentIdentification_WebmKeyId* internal_default_instance() {
    return reinterpret_cast<const LicenseRequest_ContentIdentification_WebmKeyId*>(
               &_LicenseRequest_ContentIdentification_WebmKeyId_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

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

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

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

  LicenseRequest_ContentIdentification_WebmKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseRequest_ContentIdentification_WebmKeyId>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseRequest_ContentIdentification_WebmKeyId& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseRequest_ContentIdentification_WebmKeyId& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseRequest_ContentIdentification_WebmKeyId* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseRequest.ContentIdentification.WebmKeyId";
  }
  protected:
  explicit LicenseRequest_ContentIdentification_WebmKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kHeaderFieldNumber = 1,
    kRequestIdFieldNumber = 3,
    kLicenseTypeFieldNumber = 2,
  };
  // optional bytes header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const std::string& header() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_header(ArgT0&& arg0, ArgT... args);
  std::string* mutable_header();
  PROTOBUF_MUST_USE_RESULT std::string* release_header();
  void set_allocated_header(std::string* header);
  private:
  const std::string& _internal_header() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_header(const std::string& value);
  std::string* _internal_mutable_header();
  public:

  // optional bytes request_id = 3;
  bool has_request_id() const;
  private:
  bool _internal_has_request_id() const;
  public:
  void clear_request_id();
  const std::string& request_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_request_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_request_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
  void set_allocated_request_id(std::string* request_id);
  private:
  const std::string& _internal_request_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
  std::string* _internal_mutable_request_id();
  public:

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

  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId)
 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 header_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
  int license_type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseRequest_ContentIdentification_ExistingLicense& operator=(const LicenseRequest_ContentIdentification_ExistingLicense& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseRequest_ContentIdentification_ExistingLicense& operator=(LicenseRequest_ContentIdentification_ExistingLicense&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseRequest_ContentIdentification_ExistingLicense& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseRequest_ContentIdentification_ExistingLicense* internal_default_instance() {
    return reinterpret_cast<const LicenseRequest_ContentIdentification_ExistingLicense*>(
               &_LicenseRequest_ContentIdentification_ExistingLicense_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

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

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

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

  LicenseRequest_ContentIdentification_ExistingLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseRequest_ContentIdentification_ExistingLicense>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseRequest_ContentIdentification_ExistingLicense& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseRequest_ContentIdentification_ExistingLicense& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseRequest_ContentIdentification_ExistingLicense* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseRequest.ContentIdentification.ExistingLicense";
  }
  protected:
  explicit LicenseRequest_ContentIdentification_ExistingLicense(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSessionUsageTableEntryFieldNumber = 4,
    kLicenseIdFieldNumber = 1,
    kSecondsSinceStartedFieldNumber = 2,
    kSecondsSinceLastPlayedFieldNumber = 3,
  };
  // optional bytes session_usage_table_entry = 4;
  bool has_session_usage_table_entry() const;
  private:
  bool _internal_has_session_usage_table_entry() const;
  public:
  void clear_session_usage_table_entry();
  const std::string& session_usage_table_entry() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_session_usage_table_entry(ArgT0&& arg0, ArgT... args);
  std::string* mutable_session_usage_table_entry();
  PROTOBUF_MUST_USE_RESULT std::string* release_session_usage_table_entry();
  void set_allocated_session_usage_table_entry(std::string* session_usage_table_entry);
  private:
  const std::string& _internal_session_usage_table_entry() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_usage_table_entry(const std::string& value);
  std::string* _internal_mutable_session_usage_table_entry();
  public:

  // optional .video_widevine.LicenseIdentification license_id = 1;
  bool has_license_id() const;
  private:
  bool _internal_has_license_id() const;
  public:
  void clear_license_id();
  const ::video_widevine::LicenseIdentification& license_id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
  ::video_widevine::LicenseIdentification* mutable_license_id();
  void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
  private:
  const ::video_widevine::LicenseIdentification& _internal_license_id() const;
  ::video_widevine::LicenseIdentification* _internal_mutable_license_id();
  public:
  void unsafe_arena_set_allocated_license_id(
      ::video_widevine::LicenseIdentification* license_id);
  ::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();

  // optional int64 seconds_since_started = 2;
  bool has_seconds_since_started() const;
  private:
  bool _internal_has_seconds_since_started() const;
  public:
  void clear_seconds_since_started();
  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_started() const;
  void set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds_since_started() const;
  void _internal_set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 seconds_since_last_played = 3;
  bool has_seconds_since_last_played() const;
  private:
  bool _internal_has_seconds_since_last_played() const;
  public:
  void clear_seconds_since_last_played();
  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_last_played() const;
  void set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds_since_last_played() const;
  void _internal_set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense)
 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 session_usage_table_entry_;
  ::video_widevine::LicenseIdentification* license_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_started_;
  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_last_played_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseRequest_ContentIdentification_InitData& operator=(const LicenseRequest_ContentIdentification_InitData& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseRequest_ContentIdentification_InitData& operator=(LicenseRequest_ContentIdentification_InitData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseRequest_ContentIdentification_InitData& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseRequest_ContentIdentification_InitData* internal_default_instance() {
    return reinterpret_cast<const LicenseRequest_ContentIdentification_InitData*>(
               &_LicenseRequest_ContentIdentification_InitData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

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

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

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

  LicenseRequest_ContentIdentification_InitData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseRequest_ContentIdentification_InitData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseRequest_ContentIdentification_InitData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseRequest_ContentIdentification_InitData& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseRequest_ContentIdentification_InitData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseRequest.ContentIdentification.InitData";
  }
  protected:
  explicit LicenseRequest_ContentIdentification_InitData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LicenseRequest_ContentIdentification_InitData_InitDataType InitDataType;
  static constexpr InitDataType CENC =
    LicenseRequest_ContentIdentification_InitData_InitDataType_CENC;
  static constexpr InitDataType WEBM =
    LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM;
  static inline bool InitDataType_IsValid(int value) {
    return LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value);
  }
  static constexpr InitDataType InitDataType_MIN =
    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MIN;
  static constexpr InitDataType InitDataType_MAX =
    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX;
  static constexpr int InitDataType_ARRAYSIZE =
    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  InitDataType_descriptor() {
    return LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
  }
  template<typename T>
  static inline const std::string& InitDataType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, InitDataType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function InitDataType_Name.");
    return LicenseRequest_ContentIdentification_InitData_InitDataType_Name(enum_t_value);
  }
  static inline bool InitDataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      InitDataType* value) {
    return LicenseRequest_ContentIdentification_InitData_InitDataType_Parse(name, value);
  }

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

  enum : int {
    kInitDataFieldNumber = 2,
    kRequestIdFieldNumber = 4,
    kInitDataTypeFieldNumber = 1,
    kLicenseTypeFieldNumber = 3,
  };
  // optional bytes init_data = 2;
  bool has_init_data() const;
  private:
  bool _internal_has_init_data() const;
  public:
  void clear_init_data();
  const std::string& init_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_init_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_init_data();
  PROTOBUF_MUST_USE_RESULT std::string* release_init_data();
  void set_allocated_init_data(std::string* init_data);
  private:
  const std::string& _internal_init_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_init_data(const std::string& value);
  std::string* _internal_mutable_init_data();
  public:

  // optional bytes request_id = 4;
  bool has_request_id() const;
  private:
  bool _internal_has_request_id() const;
  public:
  void clear_request_id();
  const std::string& request_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_request_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_request_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
  void set_allocated_request_id(std::string* request_id);
  private:
  const std::string& _internal_request_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
  std::string* _internal_mutable_request_id();
  public:

  // optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1 [default = CENC];
  bool has_init_data_type() const;
  private:
  bool _internal_has_init_data_type() const;
  public:
  void clear_init_data_type();
  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType init_data_type() const;
  void set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
  private:
  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType _internal_init_data_type() const;
  void _internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
  public:

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

  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.InitData)
 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 init_data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
  int init_data_type_;
  int license_type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseRequest_ContentIdentification& operator=(const LicenseRequest_ContentIdentification& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseRequest_ContentIdentification& operator=(LicenseRequest_ContentIdentification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseRequest_ContentIdentification& default_instance() {
    return *internal_default_instance();
  }
  enum ContentIdVariantCase {
    kWidevinePsshData = 1,
    kWebmKeyId = 2,
    kExistingLicense = 3,
    kInitData = 4,
    CONTENT_ID_VARIANT_NOT_SET = 0,
  };

  static inline const LicenseRequest_ContentIdentification* internal_default_instance() {
    return reinterpret_cast<const LicenseRequest_ContentIdentification*>(
               &_LicenseRequest_ContentIdentification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

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

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

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

  LicenseRequest_ContentIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseRequest_ContentIdentification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseRequest_ContentIdentification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseRequest_ContentIdentification& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseRequest_ContentIdentification* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseRequest.ContentIdentification";
  }
  protected:
  explicit LicenseRequest_ContentIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LicenseRequest_ContentIdentification_WidevinePsshData WidevinePsshData;
  typedef LicenseRequest_ContentIdentification_WebmKeyId WebmKeyId;
  typedef LicenseRequest_ContentIdentification_ExistingLicense ExistingLicense;
  typedef LicenseRequest_ContentIdentification_InitData InitData;

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

  enum : int {
    kWidevinePsshDataFieldNumber = 1,
    kWebmKeyIdFieldNumber = 2,
    kExistingLicenseFieldNumber = 3,
    kInitDataFieldNumber = 4,
  };
  // .video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData widevine_pssh_data = 1;
  bool has_widevine_pssh_data() const;
  private:
  bool _internal_has_widevine_pssh_data() const;
  public:
  void clear_widevine_pssh_data();
  const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& widevine_pssh_data() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* release_widevine_pssh_data();
  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* mutable_widevine_pssh_data();
  void set_allocated_widevine_pssh_data(::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data);
  private:
  const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& _internal_widevine_pssh_data() const;
  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* _internal_mutable_widevine_pssh_data();
  public:
  void unsafe_arena_set_allocated_widevine_pssh_data(
      ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data);
  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* unsafe_arena_release_widevine_pssh_data();

  // .video_widevine.LicenseRequest.ContentIdentification.WebmKeyId webm_key_id = 2;
  bool has_webm_key_id() const;
  private:
  bool _internal_has_webm_key_id() const;
  public:
  void clear_webm_key_id();
  const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& webm_key_id() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* release_webm_key_id();
  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* mutable_webm_key_id();
  void set_allocated_webm_key_id(::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id);
  private:
  const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& _internal_webm_key_id() const;
  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* _internal_mutable_webm_key_id();
  public:
  void unsafe_arena_set_allocated_webm_key_id(
      ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id);
  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* unsafe_arena_release_webm_key_id();

  // .video_widevine.LicenseRequest.ContentIdentification.ExistingLicense existing_license = 3;
  bool has_existing_license() const;
  private:
  bool _internal_has_existing_license() const;
  public:
  void clear_existing_license();
  const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& existing_license() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* release_existing_license();
  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* mutable_existing_license();
  void set_allocated_existing_license(::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license);
  private:
  const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& _internal_existing_license() const;
  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* _internal_mutable_existing_license();
  public:
  void unsafe_arena_set_allocated_existing_license(
      ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license);
  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* unsafe_arena_release_existing_license();

  // .video_widevine.LicenseRequest.ContentIdentification.InitData init_data = 4;
  bool has_init_data() const;
  private:
  bool _internal_has_init_data() const;
  public:
  void clear_init_data();
  const ::video_widevine::LicenseRequest_ContentIdentification_InitData& init_data() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_InitData* release_init_data();
  ::video_widevine::LicenseRequest_ContentIdentification_InitData* mutable_init_data();
  void set_allocated_init_data(::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data);
  private:
  const ::video_widevine::LicenseRequest_ContentIdentification_InitData& _internal_init_data() const;
  ::video_widevine::LicenseRequest_ContentIdentification_InitData* _internal_mutable_init_data();
  public:
  void unsafe_arena_set_allocated_init_data(
      ::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data);
  ::video_widevine::LicenseRequest_ContentIdentification_InitData* unsafe_arena_release_init_data();

  void clear_content_id_variant();
  ContentIdVariantCase content_id_variant_case() const;
  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification)
 private:
  class _Internal;
  void set_has_widevine_pssh_data();
  void set_has_webm_key_id();
  void set_has_existing_license();
  void set_has_init_data();

  inline bool has_content_id_variant() const;
  inline void clear_has_content_id_variant();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union ContentIdVariantUnion {
    constexpr ContentIdVariantUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data_;
    ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id_;
    ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license_;
    ::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data_;
  } content_id_variant_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseRequest& operator=(const LicenseRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseRequest& operator=(LicenseRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseRequest* internal_default_instance() {
    return reinterpret_cast<const LicenseRequest*>(
               &_LicenseRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

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

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

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

  LicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseRequest& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseRequest";
  }
  protected:
  explicit LicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LicenseRequest_ContentIdentification ContentIdentification;

  typedef LicenseRequest_RequestType RequestType;
  static constexpr RequestType NEW =
    LicenseRequest_RequestType_NEW;
  static constexpr RequestType RENEWAL =
    LicenseRequest_RequestType_RENEWAL;
  static constexpr RequestType RELEASE =
    LicenseRequest_RequestType_RELEASE;
  static inline bool RequestType_IsValid(int value) {
    return LicenseRequest_RequestType_IsValid(value);
  }
  static constexpr RequestType RequestType_MIN =
    LicenseRequest_RequestType_RequestType_MIN;
  static constexpr RequestType RequestType_MAX =
    LicenseRequest_RequestType_RequestType_MAX;
  static constexpr int RequestType_ARRAYSIZE =
    LicenseRequest_RequestType_RequestType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RequestType_descriptor() {
    return LicenseRequest_RequestType_descriptor();
  }
  template<typename T>
  static inline const std::string& RequestType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RequestType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RequestType_Name.");
    return LicenseRequest_RequestType_Name(enum_t_value);
  }
  static inline bool RequestType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RequestType* value) {
    return LicenseRequest_RequestType_Parse(name, value);
  }

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

  enum : int {
    kKeyControlNonceDeprecatedFieldNumber = 5,
    kClientIdFieldNumber = 1,
    kContentIdFieldNumber = 2,
    kEncryptedClientIdFieldNumber = 8,
    kRequestTimeFieldNumber = 4,
    kKeyControlNonceFieldNumber = 7,
    kTypeFieldNumber = 3,
    kProtocolVersionFieldNumber = 6,
  };
  // optional bytes key_control_nonce_deprecated = 5;
  bool has_key_control_nonce_deprecated() const;
  private:
  bool _internal_has_key_control_nonce_deprecated() const;
  public:
  void clear_key_control_nonce_deprecated();
  const std::string& key_control_nonce_deprecated() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key_control_nonce_deprecated(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key_control_nonce_deprecated();
  PROTOBUF_MUST_USE_RESULT std::string* release_key_control_nonce_deprecated();
  void set_allocated_key_control_nonce_deprecated(std::string* key_control_nonce_deprecated);
  private:
  const std::string& _internal_key_control_nonce_deprecated() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_control_nonce_deprecated(const std::string& value);
  std::string* _internal_mutable_key_control_nonce_deprecated();
  public:

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

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

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

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

  // optional uint32 key_control_nonce = 7;
  bool has_key_control_nonce() const;
  private:
  bool _internal_has_key_control_nonce() const;
  public:
  void clear_key_control_nonce();
  ::PROTOBUF_NAMESPACE_ID::uint32 key_control_nonce() const;
  void set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_control_nonce() const;
  void _internal_set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.LicenseRequest.RequestType type = 3;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::video_widevine::LicenseRequest_RequestType type() const;
  void set_type(::video_widevine::LicenseRequest_RequestType value);
  private:
  ::video_widevine::LicenseRequest_RequestType _internal_type() const;
  void _internal_set_type(::video_widevine::LicenseRequest_RequestType value);
  public:

  // optional .video_widevine.ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
  bool has_protocol_version() const;
  private:
  bool _internal_has_protocol_version() const;
  public:
  void clear_protocol_version();
  ::video_widevine::ProtocolVersion protocol_version() const;
  void set_protocol_version(::video_widevine::ProtocolVersion value);
  private:
  ::video_widevine::ProtocolVersion _internal_protocol_version() const;
  void _internal_set_protocol_version(::video_widevine::ProtocolVersion value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_control_nonce_deprecated_;
  ::video_widevine::ClientIdentification* client_id_;
  ::video_widevine::LicenseRequest_ContentIdentification* content_id_;
  ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 request_time_;
  ::PROTOBUF_NAMESPACE_ID::uint32 key_control_nonce_;
  int type_;
  int protocol_version_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LicenseError& operator=(const LicenseError& from) {
    CopyFrom(from);
    return *this;
  }
  inline LicenseError& operator=(LicenseError&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LicenseError& default_instance() {
    return *internal_default_instance();
  }
  static inline const LicenseError* internal_default_instance() {
    return reinterpret_cast<const LicenseError*>(
               &_LicenseError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

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

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

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

  LicenseError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LicenseError>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LicenseError& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LicenseError& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LicenseError* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.LicenseError";
  }
  protected:
  explicit LicenseError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LicenseError_Error Error;
  static constexpr Error INVALID_DRM_DEVICE_CERTIFICATE =
    LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE;
  static constexpr Error REVOKED_DRM_DEVICE_CERTIFICATE =
    LicenseError_Error_REVOKED_DRM_DEVICE_CERTIFICATE;
  static constexpr Error SERVICE_UNAVAILABLE =
    LicenseError_Error_SERVICE_UNAVAILABLE;
  static constexpr Error EXPIRED_DRM_DEVICE_CERTIFICATE =
    LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE;
  static inline bool Error_IsValid(int value) {
    return LicenseError_Error_IsValid(value);
  }
  static constexpr Error Error_MIN =
    LicenseError_Error_Error_MIN;
  static constexpr Error Error_MAX =
    LicenseError_Error_Error_MAX;
  static constexpr int Error_ARRAYSIZE =
    LicenseError_Error_Error_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Error_descriptor() {
    return LicenseError_Error_descriptor();
  }
  template<typename T>
  static inline const std::string& Error_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Error>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Error_Name.");
    return LicenseError_Error_Name(enum_t_value);
  }
  static inline bool Error_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Error* value) {
    return LicenseError_Error_Parse(name, value);
  }

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

  enum : int {
    kErrorCodeFieldNumber = 1,
  };
  // optional .video_widevine.LicenseError.Error error_code = 1;
  bool has_error_code() const;
  private:
  bool _internal_has_error_code() const;
  public:
  void clear_error_code();
  ::video_widevine::LicenseError_Error error_code() const;
  void set_error_code(::video_widevine::LicenseError_Error value);
  private:
  ::video_widevine::LicenseError_Error _internal_error_code() const;
  void _internal_set_error_code(::video_widevine::LicenseError_Error value);
  public:

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

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

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

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

  inline MetricData_TypeValue& operator=(const MetricData_TypeValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetricData_TypeValue& operator=(MetricData_TypeValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MetricData_TypeValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricData_TypeValue* internal_default_instance() {
    return reinterpret_cast<const MetricData_TypeValue*>(
               &_MetricData_TypeValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

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

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

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

  MetricData_TypeValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricData_TypeValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetricData_TypeValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MetricData_TypeValue& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetricData_TypeValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.MetricData.TypeValue";
  }
  protected:
  explicit MetricData_TypeValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // optional int64 value = 2 [default = 0];
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  ::PROTOBUF_NAMESPACE_ID::int64 value() const;
  void set_value(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_value() const;
  void _internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional .video_widevine.MetricData.MetricType type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::video_widevine::MetricData_MetricType type() const;
  void set_type(::video_widevine::MetricData_MetricType value);
  private:
  ::video_widevine::MetricData_MetricType _internal_type() const;
  void _internal_set_type(::video_widevine::MetricData_MetricType value);
  public:

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

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

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

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

  inline MetricData& operator=(const MetricData& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetricData& operator=(MetricData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MetricData& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricData* internal_default_instance() {
    return reinterpret_cast<const MetricData*>(
               &_MetricData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

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

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

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

  MetricData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetricData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MetricData& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetricData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.MetricData";
  }
  protected:
  explicit MetricData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef MetricData_TypeValue TypeValue;

  typedef MetricData_MetricType MetricType;
  static constexpr MetricType LATENCY =
    MetricData_MetricType_LATENCY;
  static constexpr MetricType TIMESTAMP =
    MetricData_MetricType_TIMESTAMP;
  static inline bool MetricType_IsValid(int value) {
    return MetricData_MetricType_IsValid(value);
  }
  static constexpr MetricType MetricType_MIN =
    MetricData_MetricType_MetricType_MIN;
  static constexpr MetricType MetricType_MAX =
    MetricData_MetricType_MetricType_MAX;
  static constexpr int MetricType_ARRAYSIZE =
    MetricData_MetricType_MetricType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MetricType_descriptor() {
    return MetricData_MetricType_descriptor();
  }
  template<typename T>
  static inline const std::string& MetricType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MetricType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MetricType_Name.");
    return MetricData_MetricType_Name(enum_t_value);
  }
  static inline bool MetricType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MetricType* value) {
    return MetricData_MetricType_Parse(name, value);
  }

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

  enum : int {
    kMetricDataFieldNumber = 2,
    kStageNameFieldNumber = 1,
  };
  // repeated .video_widevine.MetricData.TypeValue metric_data = 2;
  int metric_data_size() const;
  private:
  int _internal_metric_data_size() const;
  public:
  void clear_metric_data();
  ::video_widevine::MetricData_TypeValue* mutable_metric_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >*
      mutable_metric_data();
  private:
  const ::video_widevine::MetricData_TypeValue& _internal_metric_data(int index) const;
  ::video_widevine::MetricData_TypeValue* _internal_add_metric_data();
  public:
  const ::video_widevine::MetricData_TypeValue& metric_data(int index) const;
  ::video_widevine::MetricData_TypeValue* add_metric_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >&
      metric_data() const;

  // optional string stage_name = 1;
  bool has_stage_name() const;
  private:
  bool _internal_has_stage_name() const;
  public:
  void clear_stage_name();
  const std::string& stage_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stage_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stage_name();
  PROTOBUF_MUST_USE_RESULT std::string* release_stage_name();
  void set_allocated_stage_name(std::string* stage_name);
  private:
  const std::string& _internal_stage_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stage_name(const std::string& value);
  std::string* _internal_mutable_stage_name();
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue > metric_data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stage_name_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline VersionInfo& operator=(const VersionInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline VersionInfo& operator=(VersionInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VersionInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const VersionInfo* internal_default_instance() {
    return reinterpret_cast<const VersionInfo*>(
               &_VersionInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

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

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

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

  VersionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VersionInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VersionInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const VersionInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VersionInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.VersionInfo";
  }
  protected:
  explicit VersionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLicenseSdkVersionFieldNumber = 1,
    kLicenseServiceVersionFieldNumber = 2,
  };
  // optional string license_sdk_version = 1;
  bool has_license_sdk_version() const;
  private:
  bool _internal_has_license_sdk_version() const;
  public:
  void clear_license_sdk_version();
  const std::string& license_sdk_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_license_sdk_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_license_sdk_version();
  PROTOBUF_MUST_USE_RESULT std::string* release_license_sdk_version();
  void set_allocated_license_sdk_version(std::string* license_sdk_version);
  private:
  const std::string& _internal_license_sdk_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license_sdk_version(const std::string& value);
  std::string* _internal_mutable_license_sdk_version();
  public:

  // optional string license_service_version = 2;
  bool has_license_service_version() const;
  private:
  bool _internal_has_license_service_version() const;
  public:
  void clear_license_service_version();
  const std::string& license_service_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_license_service_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_license_service_version();
  PROTOBUF_MUST_USE_RESULT std::string* release_license_service_version();
  void set_allocated_license_service_version(std::string* license_service_version);
  private:
  const std::string& _internal_license_service_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license_service_version(const std::string& value);
  std::string* _internal_mutable_license_service_version();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.VersionInfo)
 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 license_sdk_version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_service_version_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline SignedMessage& operator=(const SignedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline SignedMessage& operator=(SignedMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SignedMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const SignedMessage* internal_default_instance() {
    return reinterpret_cast<const SignedMessage*>(
               &_SignedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

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

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

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

  SignedMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SignedMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SignedMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SignedMessage& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SignedMessage* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.SignedMessage";
  }
  protected:
  explicit SignedMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef SignedMessage_MessageType MessageType;
  static constexpr MessageType LICENSE_REQUEST =
    SignedMessage_MessageType_LICENSE_REQUEST;
  static constexpr MessageType LICENSE =
    SignedMessage_MessageType_LICENSE;
  static constexpr MessageType ERROR_RESPONSE =
    SignedMessage_MessageType_ERROR_RESPONSE;
  static constexpr MessageType SERVICE_CERTIFICATE_REQUEST =
    SignedMessage_MessageType_SERVICE_CERTIFICATE_REQUEST;
  static constexpr MessageType SERVICE_CERTIFICATE =
    SignedMessage_MessageType_SERVICE_CERTIFICATE;
  static constexpr MessageType SUB_LICENSE =
    SignedMessage_MessageType_SUB_LICENSE;
  static constexpr MessageType CAS_LICENSE_REQUEST =
    SignedMessage_MessageType_CAS_LICENSE_REQUEST;
  static constexpr MessageType CAS_LICENSE =
    SignedMessage_MessageType_CAS_LICENSE;
  static constexpr MessageType EXTERNAL_LICENSE_REQUEST =
    SignedMessage_MessageType_EXTERNAL_LICENSE_REQUEST;
  static constexpr MessageType EXTERNAL_LICENSE =
    SignedMessage_MessageType_EXTERNAL_LICENSE;
  static inline bool MessageType_IsValid(int value) {
    return SignedMessage_MessageType_IsValid(value);
  }
  static constexpr MessageType MessageType_MIN =
    SignedMessage_MessageType_MessageType_MIN;
  static constexpr MessageType MessageType_MAX =
    SignedMessage_MessageType_MessageType_MAX;
  static constexpr int MessageType_ARRAYSIZE =
    SignedMessage_MessageType_MessageType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MessageType_descriptor() {
    return SignedMessage_MessageType_descriptor();
  }
  template<typename T>
  static inline const std::string& MessageType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MessageType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MessageType_Name.");
    return SignedMessage_MessageType_Name(enum_t_value);
  }
  static inline bool MessageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MessageType* value) {
    return SignedMessage_MessageType_Parse(name, value);
  }

  typedef SignedMessage_SessionKeyType SessionKeyType;
  static constexpr SessionKeyType UNDEFINED =
    SignedMessage_SessionKeyType_UNDEFINED;
  static constexpr SessionKeyType WRAPPED_AES_KEY =
    SignedMessage_SessionKeyType_WRAPPED_AES_KEY;
  static constexpr SessionKeyType EPHEMERAL_ECC_PUBLIC_KEY =
    SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY;
  static inline bool SessionKeyType_IsValid(int value) {
    return SignedMessage_SessionKeyType_IsValid(value);
  }
  static constexpr SessionKeyType SessionKeyType_MIN =
    SignedMessage_SessionKeyType_SessionKeyType_MIN;
  static constexpr SessionKeyType SessionKeyType_MAX =
    SignedMessage_SessionKeyType_SessionKeyType_MAX;
  static constexpr int SessionKeyType_ARRAYSIZE =
    SignedMessage_SessionKeyType_SessionKeyType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SessionKeyType_descriptor() {
    return SignedMessage_SessionKeyType_descriptor();
  }
  template<typename T>
  static inline const std::string& SessionKeyType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SessionKeyType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SessionKeyType_Name.");
    return SignedMessage_SessionKeyType_Name(enum_t_value);
  }
  static inline bool SessionKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SessionKeyType* value) {
    return SignedMessage_SessionKeyType_Parse(name, value);
  }

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

  enum : int {
    kMetricDataFieldNumber = 6,
    kMsgFieldNumber = 2,
    kSignatureFieldNumber = 3,
    kSessionKeyFieldNumber = 4,
    kOemcryptoCoreMessageFieldNumber = 9,
    kRemoteAttestationFieldNumber = 5,
    kServiceVersionInfoFieldNumber = 7,
    kHashAlgorithmFieldNumber = 10,
    kUsingSecondaryKeyFieldNumber = 11,
    kTypeFieldNumber = 1,
    kSessionKeyTypeFieldNumber = 8,
  };
  // repeated .video_widevine.MetricData metric_data = 6;
  int metric_data_size() const;
  private:
  int _internal_metric_data_size() const;
  public:
  void clear_metric_data();
  ::video_widevine::MetricData* mutable_metric_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >*
      mutable_metric_data();
  private:
  const ::video_widevine::MetricData& _internal_metric_data(int index) const;
  ::video_widevine::MetricData* _internal_add_metric_data();
  public:
  const ::video_widevine::MetricData& metric_data(int index) const;
  ::video_widevine::MetricData* add_metric_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >&
      metric_data() const;

  // optional bytes msg = 2;
  bool has_msg() const;
  private:
  bool _internal_has_msg() const;
  public:
  void clear_msg();
  const std::string& msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg();
  PROTOBUF_MUST_USE_RESULT std::string* release_msg();
  void set_allocated_msg(std::string* msg);
  private:
  const std::string& _internal_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
  std::string* _internal_mutable_msg();
  public:

  // optional bytes signature = 3;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signature();
  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // optional bytes session_key = 4;
  bool has_session_key() const;
  private:
  bool _internal_has_session_key() const;
  public:
  void clear_session_key();
  const std::string& session_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_session_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_session_key();
  PROTOBUF_MUST_USE_RESULT std::string* release_session_key();
  void set_allocated_session_key(std::string* session_key);
  private:
  const std::string& _internal_session_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_key(const std::string& value);
  std::string* _internal_mutable_session_key();
  public:

  // optional bytes oemcrypto_core_message = 9;
  bool has_oemcrypto_core_message() const;
  private:
  bool _internal_has_oemcrypto_core_message() const;
  public:
  void clear_oemcrypto_core_message();
  const std::string& oemcrypto_core_message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oemcrypto_core_message();
  PROTOBUF_MUST_USE_RESULT std::string* release_oemcrypto_core_message();
  void set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message);
  private:
  const std::string& _internal_oemcrypto_core_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oemcrypto_core_message(const std::string& value);
  std::string* _internal_mutable_oemcrypto_core_message();
  public:

  // optional .video_widevine.RemoteAttestation remote_attestation = 5;
  bool has_remote_attestation() const;
  private:
  bool _internal_has_remote_attestation() const;
  public:
  void clear_remote_attestation();
  const ::video_widevine::RemoteAttestation& remote_attestation() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::RemoteAttestation* release_remote_attestation();
  ::video_widevine::RemoteAttestation* mutable_remote_attestation();
  void set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation);
  private:
  const ::video_widevine::RemoteAttestation& _internal_remote_attestation() const;
  ::video_widevine::RemoteAttestation* _internal_mutable_remote_attestation();
  public:
  void unsafe_arena_set_allocated_remote_attestation(
      ::video_widevine::RemoteAttestation* remote_attestation);
  ::video_widevine::RemoteAttestation* unsafe_arena_release_remote_attestation();

  // optional .video_widevine.VersionInfo service_version_info = 7;
  bool has_service_version_info() const;
  private:
  bool _internal_has_service_version_info() const;
  public:
  void clear_service_version_info();
  const ::video_widevine::VersionInfo& service_version_info() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::VersionInfo* release_service_version_info();
  ::video_widevine::VersionInfo* mutable_service_version_info();
  void set_allocated_service_version_info(::video_widevine::VersionInfo* service_version_info);
  private:
  const ::video_widevine::VersionInfo& _internal_service_version_info() const;
  ::video_widevine::VersionInfo* _internal_mutable_service_version_info();
  public:
  void unsafe_arena_set_allocated_service_version_info(
      ::video_widevine::VersionInfo* service_version_info);
  ::video_widevine::VersionInfo* unsafe_arena_release_service_version_info();

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

  // optional bool using_secondary_key = 11;
  bool has_using_secondary_key() const;
  private:
  bool _internal_has_using_secondary_key() const;
  public:
  void clear_using_secondary_key();
  bool using_secondary_key() const;
  void set_using_secondary_key(bool value);
  private:
  bool _internal_using_secondary_key() const;
  void _internal_set_using_secondary_key(bool value);
  public:

  // optional .video_widevine.SignedMessage.MessageType type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::video_widevine::SignedMessage_MessageType type() const;
  void set_type(::video_widevine::SignedMessage_MessageType value);
  private:
  ::video_widevine::SignedMessage_MessageType _internal_type() const;
  void _internal_set_type(::video_widevine::SignedMessage_MessageType value);
  public:

  // optional .video_widevine.SignedMessage.SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
  bool has_session_key_type() const;
  private:
  bool _internal_has_session_key_type() const;
  public:
  void clear_session_key_type();
  ::video_widevine::SignedMessage_SessionKeyType session_key_type() const;
  void set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value);
  private:
  ::video_widevine::SignedMessage_SessionKeyType _internal_session_key_type() const;
  void _internal_set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData > metric_data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oemcrypto_core_message_;
  ::video_widevine::RemoteAttestation* remote_attestation_;
  ::video_widevine::VersionInfo* service_version_info_;
  int hash_algorithm_;
  bool using_secondary_key_;
  int type_;
  int session_key_type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
};
// ===================================================================


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

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

// optional bytes request_id = 1;
inline bool LicenseIdentification::_internal_has_request_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseIdentification::has_request_id() const {
  return _internal_has_request_id();
}
inline void LicenseIdentification::clear_request_id() {
  request_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LicenseIdentification::request_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.request_id)
  return _internal_request_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseIdentification::set_request_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.request_id)
}
inline std::string* LicenseIdentification::mutable_request_id() {
  std::string* _s = _internal_mutable_request_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.request_id)
  return _s;
}
inline const std::string& LicenseIdentification::_internal_request_id() const {
  return request_id_.Get();
}
inline void LicenseIdentification::_internal_set_request_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::_internal_mutable_request_id() {
  _has_bits_[0] |= 0x00000001u;
  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::release_request_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.request_id)
  if (!_internal_has_request_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseIdentification::set_allocated_request_id(std::string* request_id) {
  if (request_id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.request_id)
}

// optional bytes session_id = 2;
inline bool LicenseIdentification::_internal_has_session_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LicenseIdentification::has_session_id() const {
  return _internal_has_session_id();
}
inline void LicenseIdentification::clear_session_id() {
  session_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LicenseIdentification::session_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.session_id)
  return _internal_session_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseIdentification::set_session_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.session_id)
}
inline std::string* LicenseIdentification::mutable_session_id() {
  std::string* _s = _internal_mutable_session_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.session_id)
  return _s;
}
inline const std::string& LicenseIdentification::_internal_session_id() const {
  return session_id_.Get();
}
inline void LicenseIdentification::_internal_set_session_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::_internal_mutable_session_id() {
  _has_bits_[0] |= 0x00000002u;
  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::release_session_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.session_id)
  if (!_internal_has_session_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseIdentification::set_allocated_session_id(std::string* session_id) {
  if (session_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.session_id)
}

// optional bytes purchase_id = 3;
inline bool LicenseIdentification::_internal_has_purchase_id() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LicenseIdentification::has_purchase_id() const {
  return _internal_has_purchase_id();
}
inline void LicenseIdentification::clear_purchase_id() {
  purchase_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& LicenseIdentification::purchase_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.purchase_id)
  return _internal_purchase_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseIdentification::set_purchase_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 purchase_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.purchase_id)
}
inline std::string* LicenseIdentification::mutable_purchase_id() {
  std::string* _s = _internal_mutable_purchase_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.purchase_id)
  return _s;
}
inline const std::string& LicenseIdentification::_internal_purchase_id() const {
  return purchase_id_.Get();
}
inline void LicenseIdentification::_internal_set_purchase_id(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  purchase_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::_internal_mutable_purchase_id() {
  _has_bits_[0] |= 0x00000004u;
  return purchase_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::release_purchase_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.purchase_id)
  if (!_internal_has_purchase_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return purchase_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseIdentification::set_allocated_purchase_id(std::string* purchase_id) {
  if (purchase_id != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  purchase_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), purchase_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.purchase_id)
}

// optional .video_widevine.LicenseType type = 4;
inline bool LicenseIdentification::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool LicenseIdentification::has_type() const {
  return _internal_has_type();
}
inline void LicenseIdentification::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::video_widevine::LicenseType LicenseIdentification::_internal_type() const {
  return static_cast< ::video_widevine::LicenseType >(type_);
}
inline ::video_widevine::LicenseType LicenseIdentification::type() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.type)
  return _internal_type();
}
inline void LicenseIdentification::_internal_set_type(::video_widevine::LicenseType value) {
  assert(::video_widevine::LicenseType_IsValid(value));
  _has_bits_[0] |= 0x00000400u;
  type_ = value;
}
inline void LicenseIdentification::set_type(::video_widevine::LicenseType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.type)
}

// optional int32 version = 5;
inline bool LicenseIdentification::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool LicenseIdentification::has_version() const {
  return _internal_has_version();
}
inline void LicenseIdentification::clear_version() {
  version_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::_internal_version() const {
  return version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::version() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.version)
  return _internal_version();
}
inline void LicenseIdentification::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000200u;
  version_ = value;
}
inline void LicenseIdentification::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.version)
}

// optional bytes provider_session_token = 6;
inline bool LicenseIdentification::_internal_has_provider_session_token() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LicenseIdentification::has_provider_session_token() const {
  return _internal_has_provider_session_token();
}
inline void LicenseIdentification::clear_provider_session_token() {
  provider_session_token_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& LicenseIdentification::provider_session_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.provider_session_token)
  return _internal_provider_session_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseIdentification::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.provider_session_token)
}
inline std::string* LicenseIdentification::mutable_provider_session_token() {
  std::string* _s = _internal_mutable_provider_session_token();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.provider_session_token)
  return _s;
}
inline const std::string& LicenseIdentification::_internal_provider_session_token() const {
  return provider_session_token_.Get();
}
inline void LicenseIdentification::_internal_set_provider_session_token(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::_internal_mutable_provider_session_token() {
  _has_bits_[0] |= 0x00000008u;
  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseIdentification::release_provider_session_token() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.provider_session_token)
  if (!_internal_has_provider_session_token()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseIdentification::set_allocated_provider_session_token(std::string* provider_session_token) {
  if (provider_session_token != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.provider_session_token)
}

// optional int64 original_rental_duration_seconds = 7;
inline bool LicenseIdentification::_internal_has_original_rental_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LicenseIdentification::has_original_rental_duration_seconds() const {
  return _internal_has_original_rental_duration_seconds();
}
inline void LicenseIdentification::clear_original_rental_duration_seconds() {
  original_rental_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_rental_duration_seconds() const {
  return original_rental_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_rental_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_rental_duration_seconds)
  return _internal_original_rental_duration_seconds();
}
inline void LicenseIdentification::_internal_set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000010u;
  original_rental_duration_seconds_ = value;
}
inline void LicenseIdentification::set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_original_rental_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_rental_duration_seconds)
}

// optional int64 original_playback_duration_seconds = 8;
inline bool LicenseIdentification::_internal_has_original_playback_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool LicenseIdentification::has_original_playback_duration_seconds() const {
  return _internal_has_original_playback_duration_seconds();
}
inline void LicenseIdentification::clear_original_playback_duration_seconds() {
  original_playback_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_playback_duration_seconds() const {
  return original_playback_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_playback_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_playback_duration_seconds)
  return _internal_original_playback_duration_seconds();
}
inline void LicenseIdentification::_internal_set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000020u;
  original_playback_duration_seconds_ = value;
}
inline void LicenseIdentification::set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_original_playback_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_playback_duration_seconds)
}

// optional int64 original_start_time_seconds = 9;
inline bool LicenseIdentification::_internal_has_original_start_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool LicenseIdentification::has_original_start_time_seconds() const {
  return _internal_has_original_start_time_seconds();
}
inline void LicenseIdentification::clear_original_start_time_seconds() {
  original_start_time_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_start_time_seconds() const {
  return original_start_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_start_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_start_time_seconds)
  return _internal_original_start_time_seconds();
}
inline void LicenseIdentification::_internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000040u;
  original_start_time_seconds_ = value;
}
inline void LicenseIdentification::set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_original_start_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_start_time_seconds)
}

// optional int64 original_renewal_recovery_duration_seconds = 10;
inline bool LicenseIdentification::_internal_has_original_renewal_recovery_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool LicenseIdentification::has_original_renewal_recovery_duration_seconds() const {
  return _internal_has_original_renewal_recovery_duration_seconds();
}
inline void LicenseIdentification::clear_original_renewal_recovery_duration_seconds() {
  original_renewal_recovery_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_renewal_recovery_duration_seconds() const {
  return original_renewal_recovery_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_renewal_recovery_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_renewal_recovery_duration_seconds)
  return _internal_original_renewal_recovery_duration_seconds();
}
inline void LicenseIdentification::_internal_set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000080u;
  original_renewal_recovery_duration_seconds_ = value;
}
inline void LicenseIdentification::set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_original_renewal_recovery_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_renewal_recovery_duration_seconds)
}

// optional int64 original_renewal_delay_seconds = 11;
inline bool LicenseIdentification::_internal_has_original_renewal_delay_seconds() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool LicenseIdentification::has_original_renewal_delay_seconds() const {
  return _internal_has_original_renewal_delay_seconds();
}
inline void LicenseIdentification::clear_original_renewal_delay_seconds() {
  original_renewal_delay_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_renewal_delay_seconds() const {
  return original_renewal_delay_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_renewal_delay_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_renewal_delay_seconds)
  return _internal_original_renewal_delay_seconds();
}
inline void LicenseIdentification::_internal_set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000100u;
  original_renewal_delay_seconds_ = value;
}
inline void LicenseIdentification::set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_original_renewal_delay_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_renewal_delay_seconds)
}

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

// LicenseCategorySpec

// optional .video_widevine.LicenseCategorySpec.LicenseCategory license_category = 1;
inline bool LicenseCategorySpec::_internal_has_license_category() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseCategorySpec::has_license_category() const {
  return _internal_has_license_category();
}
inline void LicenseCategorySpec::clear_license_category() {
  license_category_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::video_widevine::LicenseCategorySpec_LicenseCategory LicenseCategorySpec::_internal_license_category() const {
  return static_cast< ::video_widevine::LicenseCategorySpec_LicenseCategory >(license_category_);
}
inline ::video_widevine::LicenseCategorySpec_LicenseCategory LicenseCategorySpec::license_category() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.license_category)
  return _internal_license_category();
}
inline void LicenseCategorySpec::_internal_set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value) {
  assert(::video_widevine::LicenseCategorySpec_LicenseCategory_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  license_category_ = value;
}
inline void LicenseCategorySpec::set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value) {
  _internal_set_license_category(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.license_category)
}

// bytes content_id = 2;
inline bool LicenseCategorySpec::_internal_has_content_id() const {
  return content_or_group_id_case() == kContentId;
}
inline bool LicenseCategorySpec::has_content_id() const {
  return _internal_has_content_id();
}
inline void LicenseCategorySpec::set_has_content_id() {
  _oneof_case_[0] = kContentId;
}
inline void LicenseCategorySpec::clear_content_id() {
  if (_internal_has_content_id()) {
    content_or_group_id_.content_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_content_or_group_id();
  }
}
inline const std::string& LicenseCategorySpec::content_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.content_id)
  return _internal_content_id();
}
template <typename ArgT0, typename... ArgT>
inline void LicenseCategorySpec::set_content_id(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_content_id()) {
    clear_content_or_group_id();
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.content_id)
}
inline std::string* LicenseCategorySpec::mutable_content_id() {
  std::string* _s = _internal_mutable_content_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseCategorySpec.content_id)
  return _s;
}
inline const std::string& LicenseCategorySpec::_internal_content_id() const {
  if (_internal_has_content_id()) {
    return content_or_group_id_.content_id_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void LicenseCategorySpec::_internal_set_content_id(const std::string& value) {
  if (!_internal_has_content_id()) {
    clear_content_or_group_id();
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseCategorySpec::_internal_mutable_content_id() {
  if (!_internal_has_content_id()) {
    clear_content_or_group_id();
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return content_or_group_id_.content_id_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseCategorySpec::release_content_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseCategorySpec.content_id)
  if (_internal_has_content_id()) {
    clear_has_content_or_group_id();
    return content_or_group_id_.content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void LicenseCategorySpec::set_allocated_content_id(std::string* content_id) {
  if (has_content_or_group_id()) {
    clear_content_or_group_id();
  }
  if (content_id != nullptr) {
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(content_id);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(content_id);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseCategorySpec.content_id)
}

// bytes group_id = 3;
inline bool LicenseCategorySpec::_internal_has_group_id() const {
  return content_or_group_id_case() == kGroupId;
}
inline bool LicenseCategorySpec::has_group_id() const {
  return _internal_has_group_id();
}
inline void LicenseCategorySpec::set_has_group_id() {
  _oneof_case_[0] = kGroupId;
}
inline void LicenseCategorySpec::clear_group_id() {
  if (_internal_has_group_id()) {
    content_or_group_id_.group_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_content_or_group_id();
  }
}
inline const std::string& LicenseCategorySpec::group_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.group_id)
  return _internal_group_id();
}
template <typename ArgT0, typename... ArgT>
inline void LicenseCategorySpec::set_group_id(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_group_id()) {
    clear_content_or_group_id();
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.group_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.group_id)
}
inline std::string* LicenseCategorySpec::mutable_group_id() {
  std::string* _s = _internal_mutable_group_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseCategorySpec.group_id)
  return _s;
}
inline const std::string& LicenseCategorySpec::_internal_group_id() const {
  if (_internal_has_group_id()) {
    return content_or_group_id_.group_id_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void LicenseCategorySpec::_internal_set_group_id(const std::string& value) {
  if (!_internal_has_group_id()) {
    clear_content_or_group_id();
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseCategorySpec::_internal_mutable_group_id() {
  if (!_internal_has_group_id()) {
    clear_content_or_group_id();
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return content_or_group_id_.group_id_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseCategorySpec::release_group_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseCategorySpec.group_id)
  if (_internal_has_group_id()) {
    clear_has_content_or_group_id();
    return content_or_group_id_.group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void LicenseCategorySpec::set_allocated_group_id(std::string* group_id) {
  if (has_content_or_group_id()) {
    clear_content_or_group_id();
  }
  if (group_id != nullptr) {
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(group_id);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(group_id);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseCategorySpec.group_id)
}

inline bool LicenseCategorySpec::has_content_or_group_id() const {
  return content_or_group_id_case() != CONTENT_OR_GROUP_ID_NOT_SET;
}
inline void LicenseCategorySpec::clear_has_content_or_group_id() {
  _oneof_case_[0] = CONTENT_OR_GROUP_ID_NOT_SET;
}
inline LicenseCategorySpec::ContentOrGroupIdCase LicenseCategorySpec::content_or_group_id_case() const {
  return LicenseCategorySpec::ContentOrGroupIdCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ProxyInfo

// optional .video_widevine.DrmCertificate.ServiceType sdk_type = 1;
inline bool ProxyInfo::_internal_has_sdk_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProxyInfo::has_sdk_type() const {
  return _internal_has_sdk_type();
}
inline void ProxyInfo::clear_sdk_type() {
  sdk_type_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::video_widevine::DrmCertificate_ServiceType ProxyInfo::_internal_sdk_type() const {
  return static_cast< ::video_widevine::DrmCertificate_ServiceType >(sdk_type_);
}
inline ::video_widevine::DrmCertificate_ServiceType ProxyInfo::sdk_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.ProxyInfo.sdk_type)
  return _internal_sdk_type();
}
inline void ProxyInfo::_internal_set_sdk_type(::video_widevine::DrmCertificate_ServiceType value) {
  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  sdk_type_ = value;
}
inline void ProxyInfo::set_sdk_type(::video_widevine::DrmCertificate_ServiceType value) {
  _internal_set_sdk_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.ProxyInfo.sdk_type)
}

// optional string sdk_version = 2;
inline bool ProxyInfo::_internal_has_sdk_version() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ProxyInfo::has_sdk_version() const {
  return _internal_has_sdk_version();
}
inline void ProxyInfo::clear_sdk_version() {
  sdk_version_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ProxyInfo::sdk_version() const {
  // @@protoc_insertion_point(field_get:video_widevine.ProxyInfo.sdk_version)
  return _internal_sdk_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ProxyInfo::set_sdk_version(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.ProxyInfo.sdk_version)
}
inline std::string* ProxyInfo::mutable_sdk_version() {
  std::string* _s = _internal_mutable_sdk_version();
  // @@protoc_insertion_point(field_mutable:video_widevine.ProxyInfo.sdk_version)
  return _s;
}
inline const std::string& ProxyInfo::_internal_sdk_version() const {
  return sdk_version_.Get();
}
inline void ProxyInfo::_internal_set_sdk_version(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ProxyInfo::_internal_mutable_sdk_version() {
  _has_bits_[0] |= 0x00000001u;
  return sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ProxyInfo::release_sdk_version() {
  // @@protoc_insertion_point(field_release:video_widevine.ProxyInfo.sdk_version)
  if (!_internal_has_sdk_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return sdk_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ProxyInfo::set_allocated_sdk_version(std::string* sdk_version) {
  if (sdk_version != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdk_version,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProxyInfo.sdk_version)
}

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

// License_Policy

// optional bool can_play = 1 [default = false];
inline bool License_Policy::_internal_has_can_play() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool License_Policy::has_can_play() const {
  return _internal_has_can_play();
}
inline void License_Policy::clear_can_play() {
  can_play_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool License_Policy::_internal_can_play() const {
  return can_play_;
}
inline bool License_Policy::can_play() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_play)
  return _internal_can_play();
}
inline void License_Policy::_internal_set_can_play(bool value) {
  _has_bits_[0] |= 0x00000040u;
  can_play_ = value;
}
inline void License_Policy::set_can_play(bool value) {
  _internal_set_can_play(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_play)
}

// optional bool can_persist = 2 [default = false];
inline bool License_Policy::_internal_has_can_persist() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool License_Policy::has_can_persist() const {
  return _internal_has_can_persist();
}
inline void License_Policy::clear_can_persist() {
  can_persist_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool License_Policy::_internal_can_persist() const {
  return can_persist_;
}
inline bool License_Policy::can_persist() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_persist)
  return _internal_can_persist();
}
inline void License_Policy::_internal_set_can_persist(bool value) {
  _has_bits_[0] |= 0x00000080u;
  can_persist_ = value;
}
inline void License_Policy::set_can_persist(bool value) {
  _internal_set_can_persist(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_persist)
}

// optional bool can_renew = 3 [default = false];
inline bool License_Policy::_internal_has_can_renew() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool License_Policy::has_can_renew() const {
  return _internal_has_can_renew();
}
inline void License_Policy::clear_can_renew() {
  can_renew_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool License_Policy::_internal_can_renew() const {
  return can_renew_;
}
inline bool License_Policy::can_renew() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_renew)
  return _internal_can_renew();
}
inline void License_Policy::_internal_set_can_renew(bool value) {
  _has_bits_[0] |= 0x00000100u;
  can_renew_ = value;
}
inline void License_Policy::set_can_renew(bool value) {
  _internal_set_can_renew(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_renew)
}

// optional int64 rental_duration_seconds = 4 [default = 0];
inline bool License_Policy::_internal_has_rental_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool License_Policy::has_rental_duration_seconds() const {
  return _internal_has_rental_duration_seconds();
}
inline void License_Policy::clear_rental_duration_seconds() {
  rental_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_rental_duration_seconds() const {
  return rental_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::rental_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.rental_duration_seconds)
  return _internal_rental_duration_seconds();
}
inline void License_Policy::_internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  rental_duration_seconds_ = value;
}
inline void License_Policy::set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_rental_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.rental_duration_seconds)
}

// optional int64 playback_duration_seconds = 5 [default = 0];
inline bool License_Policy::_internal_has_playback_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool License_Policy::has_playback_duration_seconds() const {
  return _internal_has_playback_duration_seconds();
}
inline void License_Policy::clear_playback_duration_seconds() {
  playback_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_playback_duration_seconds() const {
  return playback_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::playback_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.playback_duration_seconds)
  return _internal_playback_duration_seconds();
}
inline void License_Policy::_internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  playback_duration_seconds_ = value;
}
inline void License_Policy::set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_playback_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.playback_duration_seconds)
}

// optional int64 license_duration_seconds = 6 [default = 0];
inline bool License_Policy::_internal_has_license_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool License_Policy::has_license_duration_seconds() const {
  return _internal_has_license_duration_seconds();
}
inline void License_Policy::clear_license_duration_seconds() {
  license_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_license_duration_seconds() const {
  return license_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::license_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.license_duration_seconds)
  return _internal_license_duration_seconds();
}
inline void License_Policy::_internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000010u;
  license_duration_seconds_ = value;
}
inline void License_Policy::set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_license_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.license_duration_seconds)
}

// optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
inline bool License_Policy::_internal_has_renewal_recovery_duration_seconds() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool License_Policy::has_renewal_recovery_duration_seconds() const {
  return _internal_has_renewal_recovery_duration_seconds();
}
inline void License_Policy::clear_renewal_recovery_duration_seconds() {
  renewal_recovery_duration_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_recovery_duration_seconds() const {
  return renewal_recovery_duration_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_recovery_duration_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_recovery_duration_seconds)
  return _internal_renewal_recovery_duration_seconds();
}
inline void License_Policy::_internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000020u;
  renewal_recovery_duration_seconds_ = value;
}
inline void License_Policy::set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_renewal_recovery_duration_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_recovery_duration_seconds)
}

// optional string renewal_server_url = 8;
inline bool License_Policy::_internal_has_renewal_server_url() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool License_Policy::has_renewal_server_url() const {
  return _internal_has_renewal_server_url();
}
inline void License_Policy::clear_renewal_server_url() {
  renewal_server_url_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& License_Policy::renewal_server_url() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_server_url)
  return _internal_renewal_server_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_Policy::set_renewal_server_url(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 renewal_server_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_server_url)
}
inline std::string* License_Policy::mutable_renewal_server_url() {
  std::string* _s = _internal_mutable_renewal_server_url();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.Policy.renewal_server_url)
  return _s;
}
inline const std::string& License_Policy::_internal_renewal_server_url() const {
  return renewal_server_url_.Get();
}
inline void License_Policy::_internal_set_renewal_server_url(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  renewal_server_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_Policy::_internal_mutable_renewal_server_url() {
  _has_bits_[0] |= 0x00000001u;
  return renewal_server_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_Policy::release_renewal_server_url() {
  // @@protoc_insertion_point(field_release:video_widevine.License.Policy.renewal_server_url)
  if (!_internal_has_renewal_server_url()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return renewal_server_url_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_Policy::set_allocated_renewal_server_url(std::string* renewal_server_url) {
  if (renewal_server_url != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  renewal_server_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), renewal_server_url,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.Policy.renewal_server_url)
}

// optional int64 renewal_delay_seconds = 9 [default = 0];
inline bool License_Policy::_internal_has_renewal_delay_seconds() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool License_Policy::has_renewal_delay_seconds() const {
  return _internal_has_renewal_delay_seconds();
}
inline void License_Policy::clear_renewal_delay_seconds() {
  renewal_delay_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_delay_seconds() const {
  return renewal_delay_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_delay_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_delay_seconds)
  return _internal_renewal_delay_seconds();
}
inline void License_Policy::_internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00001000u;
  renewal_delay_seconds_ = value;
}
inline void License_Policy::set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_renewal_delay_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_delay_seconds)
}

// optional int64 renewal_retry_interval_seconds = 10 [default = 0];
inline bool License_Policy::_internal_has_renewal_retry_interval_seconds() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool License_Policy::has_renewal_retry_interval_seconds() const {
  return _internal_has_renewal_retry_interval_seconds();
}
inline void License_Policy::clear_renewal_retry_interval_seconds() {
  renewal_retry_interval_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_retry_interval_seconds() const {
  return renewal_retry_interval_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_retry_interval_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_retry_interval_seconds)
  return _internal_renewal_retry_interval_seconds();
}
inline void License_Policy::_internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00002000u;
  renewal_retry_interval_seconds_ = value;
}
inline void License_Policy::set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_renewal_retry_interval_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_retry_interval_seconds)
}

// optional bool renew_with_usage = 11 [default = false];
inline bool License_Policy::_internal_has_renew_with_usage() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool License_Policy::has_renew_with_usage() const {
  return _internal_has_renew_with_usage();
}
inline void License_Policy::clear_renew_with_usage() {
  renew_with_usage_ = false;
  _has_bits_[0] &= ~0x00000200u;
}
inline bool License_Policy::_internal_renew_with_usage() const {
  return renew_with_usage_;
}
inline bool License_Policy::renew_with_usage() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renew_with_usage)
  return _internal_renew_with_usage();
}
inline void License_Policy::_internal_set_renew_with_usage(bool value) {
  _has_bits_[0] |= 0x00000200u;
  renew_with_usage_ = value;
}
inline void License_Policy::set_renew_with_usage(bool value) {
  _internal_set_renew_with_usage(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renew_with_usage)
}

// optional bool always_include_client_id = 12 [default = false];
inline bool License_Policy::_internal_has_always_include_client_id() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool License_Policy::has_always_include_client_id() const {
  return _internal_has_always_include_client_id();
}
inline void License_Policy::clear_always_include_client_id() {
  always_include_client_id_ = false;
  _has_bits_[0] &= ~0x00000400u;
}
inline bool License_Policy::_internal_always_include_client_id() const {
  return always_include_client_id_;
}
inline bool License_Policy::always_include_client_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.always_include_client_id)
  return _internal_always_include_client_id();
}
inline void License_Policy::_internal_set_always_include_client_id(bool value) {
  _has_bits_[0] |= 0x00000400u;
  always_include_client_id_ = value;
}
inline void License_Policy::set_always_include_client_id(bool value) {
  _internal_set_always_include_client_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.always_include_client_id)
}

// optional int64 play_start_grace_period_seconds = 13 [default = 0];
inline bool License_Policy::_internal_has_play_start_grace_period_seconds() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool License_Policy::has_play_start_grace_period_seconds() const {
  return _internal_has_play_start_grace_period_seconds();
}
inline void License_Policy::clear_play_start_grace_period_seconds() {
  play_start_grace_period_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00004000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_play_start_grace_period_seconds() const {
  return play_start_grace_period_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::play_start_grace_period_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.play_start_grace_period_seconds)
  return _internal_play_start_grace_period_seconds();
}
inline void License_Policy::_internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00004000u;
  play_start_grace_period_seconds_ = value;
}
inline void License_Policy::set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_play_start_grace_period_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.play_start_grace_period_seconds)
}

// optional bool soft_enforce_playback_duration = 14 [default = false];
inline bool License_Policy::_internal_has_soft_enforce_playback_duration() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool License_Policy::has_soft_enforce_playback_duration() const {
  return _internal_has_soft_enforce_playback_duration();
}
inline void License_Policy::clear_soft_enforce_playback_duration() {
  soft_enforce_playback_duration_ = false;
  _has_bits_[0] &= ~0x00000800u;
}
inline bool License_Policy::_internal_soft_enforce_playback_duration() const {
  return soft_enforce_playback_duration_;
}
inline bool License_Policy::soft_enforce_playback_duration() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.soft_enforce_playback_duration)
  return _internal_soft_enforce_playback_duration();
}
inline void License_Policy::_internal_set_soft_enforce_playback_duration(bool value) {
  _has_bits_[0] |= 0x00000800u;
  soft_enforce_playback_duration_ = value;
}
inline void License_Policy::set_soft_enforce_playback_duration(bool value) {
  _internal_set_soft_enforce_playback_duration(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_playback_duration)
}

// optional bool soft_enforce_rental_duration = 15 [default = true];
inline bool License_Policy::_internal_has_soft_enforce_rental_duration() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool License_Policy::has_soft_enforce_rental_duration() const {
  return _internal_has_soft_enforce_rental_duration();
}
inline void License_Policy::clear_soft_enforce_rental_duration() {
  soft_enforce_rental_duration_ = true;
  _has_bits_[0] &= ~0x00010000u;
}
inline bool License_Policy::_internal_soft_enforce_rental_duration() const {
  return soft_enforce_rental_duration_;
}
inline bool License_Policy::soft_enforce_rental_duration() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.soft_enforce_rental_duration)
  return _internal_soft_enforce_rental_duration();
}
inline void License_Policy::_internal_set_soft_enforce_rental_duration(bool value) {
  _has_bits_[0] |= 0x00010000u;
  soft_enforce_rental_duration_ = value;
}
inline void License_Policy::set_soft_enforce_rental_duration(bool value) {
  _internal_set_soft_enforce_rental_duration(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_rental_duration)
}

// optional .video_widevine.License.Policy.WatermarkingControl watermarking_control = 16 [default = WATERMARKING_CONTROL_UNSPECIFIED];
inline bool License_Policy::_internal_has_watermarking_control() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool License_Policy::has_watermarking_control() const {
  return _internal_has_watermarking_control();
}
inline void License_Policy::clear_watermarking_control() {
  watermarking_control_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline ::video_widevine::License_Policy_WatermarkingControl License_Policy::_internal_watermarking_control() const {
  return static_cast< ::video_widevine::License_Policy_WatermarkingControl >(watermarking_control_);
}
inline ::video_widevine::License_Policy_WatermarkingControl License_Policy::watermarking_control() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.watermarking_control)
  return _internal_watermarking_control();
}
inline void License_Policy::_internal_set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value) {
  assert(::video_widevine::License_Policy_WatermarkingControl_IsValid(value));
  _has_bits_[0] |= 0x00008000u;
  watermarking_control_ = value;
}
inline void License_Policy::set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value) {
  _internal_set_watermarking_control(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.watermarking_control)
}

// optional .video_widevine.DTCPUsageRules dtcp2 = 17;
inline bool License_Policy::_internal_has_dtcp2() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || dtcp2_ != nullptr);
  return value;
}
inline bool License_Policy::has_dtcp2() const {
  return _internal_has_dtcp2();
}
inline const ::video_widevine::DTCPUsageRules& License_Policy::_internal_dtcp2() const {
  const ::video_widevine::DTCPUsageRules* p = dtcp2_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DTCPUsageRules&>(
      ::video_widevine::_DTCPUsageRules_default_instance_);
}
inline const ::video_widevine::DTCPUsageRules& License_Policy::dtcp2() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.dtcp2)
  return _internal_dtcp2();
}
inline void License_Policy::unsafe_arena_set_allocated_dtcp2(
    ::video_widevine::DTCPUsageRules* dtcp2) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dtcp2_);
  }
  dtcp2_ = dtcp2;
  if (dtcp2) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.Policy.dtcp2)
}
inline ::video_widevine::DTCPUsageRules* License_Policy::release_dtcp2() {
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::DTCPUsageRules* temp = dtcp2_;
  dtcp2_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::DTCPUsageRules* License_Policy::unsafe_arena_release_dtcp2() {
  // @@protoc_insertion_point(field_release:video_widevine.License.Policy.dtcp2)
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::DTCPUsageRules* temp = dtcp2_;
  dtcp2_ = nullptr;
  return temp;
}
inline ::video_widevine::DTCPUsageRules* License_Policy::_internal_mutable_dtcp2() {
  _has_bits_[0] |= 0x00000002u;
  if (dtcp2_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::DTCPUsageRules>(GetArenaForAllocation());
    dtcp2_ = p;
  }
  return dtcp2_;
}
inline ::video_widevine::DTCPUsageRules* License_Policy::mutable_dtcp2() {
  ::video_widevine::DTCPUsageRules* _msg = _internal_mutable_dtcp2();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.Policy.dtcp2)
  return _msg;
}
inline void License_Policy::set_allocated_dtcp2(::video_widevine::DTCPUsageRules* dtcp2) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(dtcp2_);
  }
  if (dtcp2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dtcp2));
    if (message_arena != submessage_arena) {
      dtcp2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dtcp2, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  dtcp2_ = dtcp2;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.Policy.dtcp2)
}

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

// License_KeyContainer_KeyControl

// optional bytes key_control_block = 1;
inline bool License_KeyContainer_KeyControl::_internal_has_key_control_block() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool License_KeyContainer_KeyControl::has_key_control_block() const {
  return _internal_has_key_control_block();
}
inline void License_KeyContainer_KeyControl::clear_key_control_block() {
  key_control_block_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& License_KeyContainer_KeyControl::key_control_block() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyControl.key_control_block)
  return _internal_key_control_block();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_KeyContainer_KeyControl::set_key_control_block(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 key_control_block_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyControl.key_control_block)
}
inline std::string* License_KeyContainer_KeyControl::mutable_key_control_block() {
  std::string* _s = _internal_mutable_key_control_block();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyControl.key_control_block)
  return _s;
}
inline const std::string& License_KeyContainer_KeyControl::_internal_key_control_block() const {
  return key_control_block_.Get();
}
inline void License_KeyContainer_KeyControl::_internal_set_key_control_block(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  key_control_block_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyControl::_internal_mutable_key_control_block() {
  _has_bits_[0] |= 0x00000001u;
  return key_control_block_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyControl::release_key_control_block() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyControl.key_control_block)
  if (!_internal_has_key_control_block()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return key_control_block_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_KeyContainer_KeyControl::set_allocated_key_control_block(std::string* key_control_block) {
  if (key_control_block != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  key_control_block_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_control_block,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyControl.key_control_block)
}

// optional bytes iv = 2;
inline bool License_KeyContainer_KeyControl::_internal_has_iv() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool License_KeyContainer_KeyControl::has_iv() const {
  return _internal_has_iv();
}
inline void License_KeyContainer_KeyControl::clear_iv() {
  iv_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& License_KeyContainer_KeyControl::iv() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyControl.iv)
  return _internal_iv();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_KeyContainer_KeyControl::set_iv(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyControl.iv)
}
inline std::string* License_KeyContainer_KeyControl::mutable_iv() {
  std::string* _s = _internal_mutable_iv();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyControl.iv)
  return _s;
}
inline const std::string& License_KeyContainer_KeyControl::_internal_iv() const {
  return iv_.Get();
}
inline void License_KeyContainer_KeyControl::_internal_set_iv(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyControl::_internal_mutable_iv() {
  _has_bits_[0] |= 0x00000002u;
  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyControl::release_iv() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyControl.iv)
  if (!_internal_has_iv()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_KeyContainer_KeyControl::set_allocated_iv(std::string* iv) {
  if (iv != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyControl.iv)
}

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

// License_KeyContainer_OutputProtection

// optional .video_widevine.License.KeyContainer.OutputProtection.HDCP hdcp = 1 [default = HDCP_NONE];
inline bool License_KeyContainer_OutputProtection::_internal_has_hdcp() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool License_KeyContainer_OutputProtection::has_hdcp() const {
  return _internal_has_hdcp();
}
inline void License_KeyContainer_OutputProtection::clear_hdcp() {
  hdcp_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::video_widevine::License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection::_internal_hdcp() const {
  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_HDCP >(hdcp_);
}
inline ::video_widevine::License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection::hdcp() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.hdcp)
  return _internal_hdcp();
}
inline void License_KeyContainer_OutputProtection::_internal_set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value) {
  assert(::video_widevine::License_KeyContainer_OutputProtection_HDCP_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  hdcp_ = value;
}
inline void License_KeyContainer_OutputProtection::set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value) {
  _internal_set_hdcp(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.hdcp)
}

// optional .video_widevine.License.KeyContainer.OutputProtection.CGMS cgms_flags = 2 [default = CGMS_NONE];
inline bool License_KeyContainer_OutputProtection::_internal_has_cgms_flags() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool License_KeyContainer_OutputProtection::has_cgms_flags() const {
  return _internal_has_cgms_flags();
}
inline void License_KeyContainer_OutputProtection::clear_cgms_flags() {
  cgms_flags_ = 42;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::video_widevine::License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection::_internal_cgms_flags() const {
  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_CGMS >(cgms_flags_);
}
inline ::video_widevine::License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection::cgms_flags() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.cgms_flags)
  return _internal_cgms_flags();
}
inline void License_KeyContainer_OutputProtection::_internal_set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value) {
  assert(::video_widevine::License_KeyContainer_OutputProtection_CGMS_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  cgms_flags_ = value;
}
inline void License_KeyContainer_OutputProtection::set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value) {
  _internal_set_cgms_flags(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.cgms_flags)
}

// optional .video_widevine.License.KeyContainer.OutputProtection.HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
inline bool License_KeyContainer_OutputProtection::_internal_has_hdcp_srm_rule() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool License_KeyContainer_OutputProtection::has_hdcp_srm_rule() const {
  return _internal_has_hdcp_srm_rule();
}
inline void License_KeyContainer_OutputProtection::clear_hdcp_srm_rule() {
  hdcp_srm_rule_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection::_internal_hdcp_srm_rule() const {
  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule >(hdcp_srm_rule_);
}
inline ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection::hdcp_srm_rule() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.hdcp_srm_rule)
  return _internal_hdcp_srm_rule();
}
inline void License_KeyContainer_OutputProtection::_internal_set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value) {
  assert(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  hdcp_srm_rule_ = value;
}
inline void License_KeyContainer_OutputProtection::set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value) {
  _internal_set_hdcp_srm_rule(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.hdcp_srm_rule)
}

// optional bool disable_analog_output = 4 [default = false];
inline bool License_KeyContainer_OutputProtection::_internal_has_disable_analog_output() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool License_KeyContainer_OutputProtection::has_disable_analog_output() const {
  return _internal_has_disable_analog_output();
}
inline void License_KeyContainer_OutputProtection::clear_disable_analog_output() {
  disable_analog_output_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool License_KeyContainer_OutputProtection::_internal_disable_analog_output() const {
  return disable_analog_output_;
}
inline bool License_KeyContainer_OutputProtection::disable_analog_output() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.disable_analog_output)
  return _internal_disable_analog_output();
}
inline void License_KeyContainer_OutputProtection::_internal_set_disable_analog_output(bool value) {
  _has_bits_[0] |= 0x00000004u;
  disable_analog_output_ = value;
}
inline void License_KeyContainer_OutputProtection::set_disable_analog_output(bool value) {
  _internal_set_disable_analog_output(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.disable_analog_output)
}

// optional bool disable_digital_output = 5 [default = false];
inline bool License_KeyContainer_OutputProtection::_internal_has_disable_digital_output() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool License_KeyContainer_OutputProtection::has_disable_digital_output() const {
  return _internal_has_disable_digital_output();
}
inline void License_KeyContainer_OutputProtection::clear_disable_digital_output() {
  disable_digital_output_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool License_KeyContainer_OutputProtection::_internal_disable_digital_output() const {
  return disable_digital_output_;
}
inline bool License_KeyContainer_OutputProtection::disable_digital_output() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.disable_digital_output)
  return _internal_disable_digital_output();
}
inline void License_KeyContainer_OutputProtection::_internal_set_disable_digital_output(bool value) {
  _has_bits_[0] |= 0x00000008u;
  disable_digital_output_ = value;
}
inline void License_KeyContainer_OutputProtection::set_disable_digital_output(bool value) {
  _internal_set_disable_digital_output(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.disable_digital_output)
}

// optional bool allow_record = 6 [default = false];
inline bool License_KeyContainer_OutputProtection::_internal_has_allow_record() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool License_KeyContainer_OutputProtection::has_allow_record() const {
  return _internal_has_allow_record();
}
inline void License_KeyContainer_OutputProtection::clear_allow_record() {
  allow_record_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool License_KeyContainer_OutputProtection::_internal_allow_record() const {
  return allow_record_;
}
inline bool License_KeyContainer_OutputProtection::allow_record() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.allow_record)
  return _internal_allow_record();
}
inline void License_KeyContainer_OutputProtection::_internal_set_allow_record(bool value) {
  _has_bits_[0] |= 0x00000010u;
  allow_record_ = value;
}
inline void License_KeyContainer_OutputProtection::set_allow_record(bool value) {
  _internal_set_allow_record(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.allow_record)
}

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

// License_KeyContainer_VideoResolutionConstraint

// optional uint32 min_resolution_pixels = 1;
inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_min_resolution_pixels() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool License_KeyContainer_VideoResolutionConstraint::has_min_resolution_pixels() const {
  return _internal_has_min_resolution_pixels();
}
inline void License_KeyContainer_VideoResolutionConstraint::clear_min_resolution_pixels() {
  min_resolution_pixels_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::_internal_min_resolution_pixels() const {
  return min_resolution_pixels_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::min_resolution_pixels() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.min_resolution_pixels)
  return _internal_min_resolution_pixels();
}
inline void License_KeyContainer_VideoResolutionConstraint::_internal_set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  min_resolution_pixels_ = value;
}
inline void License_KeyContainer_VideoResolutionConstraint::set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_min_resolution_pixels(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.VideoResolutionConstraint.min_resolution_pixels)
}

// optional uint32 max_resolution_pixels = 2;
inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_max_resolution_pixels() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool License_KeyContainer_VideoResolutionConstraint::has_max_resolution_pixels() const {
  return _internal_has_max_resolution_pixels();
}
inline void License_KeyContainer_VideoResolutionConstraint::clear_max_resolution_pixels() {
  max_resolution_pixels_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::_internal_max_resolution_pixels() const {
  return max_resolution_pixels_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::max_resolution_pixels() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.max_resolution_pixels)
  return _internal_max_resolution_pixels();
}
inline void License_KeyContainer_VideoResolutionConstraint::_internal_set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  max_resolution_pixels_ = value;
}
inline void License_KeyContainer_VideoResolutionConstraint::set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_max_resolution_pixels(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.VideoResolutionConstraint.max_resolution_pixels)
}

// optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 3;
inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_required_protection() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || required_protection_ != nullptr);
  return value;
}
inline bool License_KeyContainer_VideoResolutionConstraint::has_required_protection() const {
  return _internal_has_required_protection();
}
inline void License_KeyContainer_VideoResolutionConstraint::clear_required_protection() {
  if (required_protection_ != nullptr) required_protection_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer_VideoResolutionConstraint::_internal_required_protection() const {
  const ::video_widevine::License_KeyContainer_OutputProtection* p = required_protection_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
}
inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer_VideoResolutionConstraint::required_protection() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
  return _internal_required_protection();
}
inline void License_KeyContainer_VideoResolutionConstraint::unsafe_arena_set_allocated_required_protection(
    ::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(required_protection_);
  }
  required_protection_ = required_protection;
  if (required_protection) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::release_required_protection() {
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
  required_protection_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::unsafe_arena_release_required_protection() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
  required_protection_ = nullptr;
  return temp;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::_internal_mutable_required_protection() {
  _has_bits_[0] |= 0x00000001u;
  if (required_protection_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
    required_protection_ = p;
  }
  return required_protection_;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::mutable_required_protection() {
  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_required_protection();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
  return _msg;
}
inline void License_KeyContainer_VideoResolutionConstraint::set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete required_protection_;
  }
  if (required_protection) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(required_protection);
    if (message_arena != submessage_arena) {
      required_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, required_protection, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  required_protection_ = required_protection;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
}

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

// License_KeyContainer_OperatorSessionKeyPermissions

// optional bool allow_encrypt = 1 [default = false];
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_encrypt() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_encrypt() const {
  return _internal_has_allow_encrypt();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_encrypt() {
  allow_encrypt_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_encrypt() const {
  return allow_encrypt_;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_encrypt() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_encrypt)
  return _internal_allow_encrypt();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_encrypt(bool value) {
  _has_bits_[0] |= 0x00000001u;
  allow_encrypt_ = value;
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_encrypt(bool value) {
  _internal_set_allow_encrypt(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_encrypt)
}

// optional bool allow_decrypt = 2 [default = false];
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_decrypt() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_decrypt() const {
  return _internal_has_allow_decrypt();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_decrypt() {
  allow_decrypt_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_decrypt() const {
  return allow_decrypt_;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_decrypt() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_decrypt)
  return _internal_allow_decrypt();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_decrypt(bool value) {
  _has_bits_[0] |= 0x00000002u;
  allow_decrypt_ = value;
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_decrypt(bool value) {
  _internal_set_allow_decrypt(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_decrypt)
}

// optional bool allow_sign = 3 [default = false];
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_sign() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_sign() const {
  return _internal_has_allow_sign();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_sign() {
  allow_sign_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_sign() const {
  return allow_sign_;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_sign() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_sign)
  return _internal_allow_sign();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_sign(bool value) {
  _has_bits_[0] |= 0x00000004u;
  allow_sign_ = value;
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_sign(bool value) {
  _internal_set_allow_sign(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_sign)
}

// optional bool allow_signature_verify = 4 [default = false];
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_signature_verify() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_signature_verify() const {
  return _internal_has_allow_signature_verify();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_signature_verify() {
  allow_signature_verify_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_signature_verify() const {
  return allow_signature_verify_;
}
inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_signature_verify() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_signature_verify)
  return _internal_allow_signature_verify();
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_signature_verify(bool value) {
  _has_bits_[0] |= 0x00000008u;
  allow_signature_verify_ = value;
}
inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_signature_verify(bool value) {
  _internal_set_allow_signature_verify(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_signature_verify)
}

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

// License_KeyContainer_KeyCategorySpec

// optional .video_widevine.License.KeyContainer.KeyCategorySpec.KeyCategory key_category = 1;
inline bool License_KeyContainer_KeyCategorySpec::_internal_has_key_category() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool License_KeyContainer_KeyCategorySpec::has_key_category() const {
  return _internal_has_key_category();
}
inline void License_KeyContainer_KeyCategorySpec::clear_key_category() {
  key_category_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec::_internal_key_category() const {
  return static_cast< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory >(key_category_);
}
inline ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec::key_category() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.key_category)
  return _internal_key_category();
}
inline void License_KeyContainer_KeyCategorySpec::_internal_set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value) {
  assert(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  key_category_ = value;
}
inline void License_KeyContainer_KeyCategorySpec::set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value) {
  _internal_set_key_category(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.key_category)
}

// bytes content_id = 2;
inline bool License_KeyContainer_KeyCategorySpec::_internal_has_content_id() const {
  return content_or_group_id_case() == kContentId;
}
inline bool License_KeyContainer_KeyCategorySpec::has_content_id() const {
  return _internal_has_content_id();
}
inline void License_KeyContainer_KeyCategorySpec::set_has_content_id() {
  _oneof_case_[0] = kContentId;
}
inline void License_KeyContainer_KeyCategorySpec::clear_content_id() {
  if (_internal_has_content_id()) {
    content_or_group_id_.content_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_content_or_group_id();
  }
}
inline const std::string& License_KeyContainer_KeyCategorySpec::content_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
  return _internal_content_id();
}
template <typename ArgT0, typename... ArgT>
inline void License_KeyContainer_KeyCategorySpec::set_content_id(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_content_id()) {
    clear_content_or_group_id();
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
}
inline std::string* License_KeyContainer_KeyCategorySpec::mutable_content_id() {
  std::string* _s = _internal_mutable_content_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
  return _s;
}
inline const std::string& License_KeyContainer_KeyCategorySpec::_internal_content_id() const {
  if (_internal_has_content_id()) {
    return content_or_group_id_.content_id_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void License_KeyContainer_KeyCategorySpec::_internal_set_content_id(const std::string& value) {
  if (!_internal_has_content_id()) {
    clear_content_or_group_id();
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyCategorySpec::_internal_mutable_content_id() {
  if (!_internal_has_content_id()) {
    clear_content_or_group_id();
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return content_or_group_id_.content_id_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyCategorySpec::release_content_id() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
  if (_internal_has_content_id()) {
    clear_has_content_or_group_id();
    return content_or_group_id_.content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void License_KeyContainer_KeyCategorySpec::set_allocated_content_id(std::string* content_id) {
  if (has_content_or_group_id()) {
    clear_content_or_group_id();
  }
  if (content_id != nullptr) {
    set_has_content_id();
    content_or_group_id_.content_id_.UnsafeSetDefault(content_id);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(content_id);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
}

// bytes group_id = 3;
inline bool License_KeyContainer_KeyCategorySpec::_internal_has_group_id() const {
  return content_or_group_id_case() == kGroupId;
}
inline bool License_KeyContainer_KeyCategorySpec::has_group_id() const {
  return _internal_has_group_id();
}
inline void License_KeyContainer_KeyCategorySpec::set_has_group_id() {
  _oneof_case_[0] = kGroupId;
}
inline void License_KeyContainer_KeyCategorySpec::clear_group_id() {
  if (_internal_has_group_id()) {
    content_or_group_id_.group_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_content_or_group_id();
  }
}
inline const std::string& License_KeyContainer_KeyCategorySpec::group_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
  return _internal_group_id();
}
template <typename ArgT0, typename... ArgT>
inline void License_KeyContainer_KeyCategorySpec::set_group_id(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_group_id()) {
    clear_content_or_group_id();
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.group_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
}
inline std::string* License_KeyContainer_KeyCategorySpec::mutable_group_id() {
  std::string* _s = _internal_mutable_group_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
  return _s;
}
inline const std::string& License_KeyContainer_KeyCategorySpec::_internal_group_id() const {
  if (_internal_has_group_id()) {
    return content_or_group_id_.group_id_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void License_KeyContainer_KeyCategorySpec::_internal_set_group_id(const std::string& value) {
  if (!_internal_has_group_id()) {
    clear_content_or_group_id();
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  content_or_group_id_.group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyCategorySpec::_internal_mutable_group_id() {
  if (!_internal_has_group_id()) {
    clear_content_or_group_id();
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return content_or_group_id_.group_id_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer_KeyCategorySpec::release_group_id() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
  if (_internal_has_group_id()) {
    clear_has_content_or_group_id();
    return content_or_group_id_.group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void License_KeyContainer_KeyCategorySpec::set_allocated_group_id(std::string* group_id) {
  if (has_content_or_group_id()) {
    clear_content_or_group_id();
  }
  if (group_id != nullptr) {
    set_has_group_id();
    content_or_group_id_.group_id_.UnsafeSetDefault(group_id);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(group_id);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
}

inline bool License_KeyContainer_KeyCategorySpec::has_content_or_group_id() const {
  return content_or_group_id_case() != CONTENT_OR_GROUP_ID_NOT_SET;
}
inline void License_KeyContainer_KeyCategorySpec::clear_has_content_or_group_id() {
  _oneof_case_[0] = CONTENT_OR_GROUP_ID_NOT_SET;
}
inline License_KeyContainer_KeyCategorySpec::ContentOrGroupIdCase License_KeyContainer_KeyCategorySpec::content_or_group_id_case() const {
  return License_KeyContainer_KeyCategorySpec::ContentOrGroupIdCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// License_KeyContainer

// optional bytes id = 1;
inline bool License_KeyContainer::_internal_has_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool License_KeyContainer::has_id() const {
  return _internal_has_id();
}
inline void License_KeyContainer::clear_id() {
  id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& License_KeyContainer::id() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_KeyContainer::set_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.id)
}
inline std::string* License_KeyContainer::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.id)
  return _s;
}
inline const std::string& License_KeyContainer::_internal_id() const {
  return id_.Get();
}
inline void License_KeyContainer::_internal_set_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::_internal_mutable_id() {
  _has_bits_[0] |= 0x00000001u;
  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::release_id() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_KeyContainer::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.id)
}

// optional bytes iv = 2;
inline bool License_KeyContainer::_internal_has_iv() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool License_KeyContainer::has_iv() const {
  return _internal_has_iv();
}
inline void License_KeyContainer::clear_iv() {
  iv_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& License_KeyContainer::iv() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.iv)
  return _internal_iv();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_KeyContainer::set_iv(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.iv)
}
inline std::string* License_KeyContainer::mutable_iv() {
  std::string* _s = _internal_mutable_iv();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.iv)
  return _s;
}
inline const std::string& License_KeyContainer::_internal_iv() const {
  return iv_.Get();
}
inline void License_KeyContainer::_internal_set_iv(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::_internal_mutable_iv() {
  _has_bits_[0] |= 0x00000002u;
  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::release_iv() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.iv)
  if (!_internal_has_iv()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_KeyContainer::set_allocated_iv(std::string* iv) {
  if (iv != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.iv)
}

// optional bytes key = 3;
inline bool License_KeyContainer::_internal_has_key() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool License_KeyContainer::has_key() const {
  return _internal_has_key();
}
inline void License_KeyContainer::clear_key() {
  key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& License_KeyContainer::key() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_KeyContainer::set_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.key)
}
inline std::string* License_KeyContainer::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key)
  return _s;
}
inline const std::string& License_KeyContainer::_internal_key() const {
  return key_.Get();
}
inline void License_KeyContainer::_internal_set_key(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::_internal_mutable_key() {
  _has_bits_[0] |= 0x00000004u;
  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::release_key() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_KeyContainer::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,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key)
}

// optional .video_widevine.License.KeyContainer.KeyType type = 4;
inline bool License_KeyContainer::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool License_KeyContainer::has_type() const {
  return _internal_has_type();
}
inline void License_KeyContainer::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::video_widevine::License_KeyContainer_KeyType License_KeyContainer::_internal_type() const {
  return static_cast< ::video_widevine::License_KeyContainer_KeyType >(type_);
}
inline ::video_widevine::License_KeyContainer_KeyType License_KeyContainer::type() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.type)
  return _internal_type();
}
inline void License_KeyContainer::_internal_set_type(::video_widevine::License_KeyContainer_KeyType value) {
  assert(::video_widevine::License_KeyContainer_KeyType_IsValid(value));
  _has_bits_[0] |= 0x00000400u;
  type_ = value;
}
inline void License_KeyContainer::set_type(::video_widevine::License_KeyContainer_KeyType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.type)
}

// optional .video_widevine.License.KeyContainer.SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
inline bool License_KeyContainer::_internal_has_level() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool License_KeyContainer::has_level() const {
  return _internal_has_level();
}
inline void License_KeyContainer::clear_level() {
  level_ = 1;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::video_widevine::License_KeyContainer_SecurityLevel License_KeyContainer::_internal_level() const {
  return static_cast< ::video_widevine::License_KeyContainer_SecurityLevel >(level_);
}
inline ::video_widevine::License_KeyContainer_SecurityLevel License_KeyContainer::level() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.level)
  return _internal_level();
}
inline void License_KeyContainer::_internal_set_level(::video_widevine::License_KeyContainer_SecurityLevel value) {
  assert(::video_widevine::License_KeyContainer_SecurityLevel_IsValid(value));
  _has_bits_[0] |= 0x00000800u;
  level_ = value;
}
inline void License_KeyContainer::set_level(::video_widevine::License_KeyContainer_SecurityLevel value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.level)
}

// optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 6;
inline bool License_KeyContainer::_internal_has_required_protection() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || required_protection_ != nullptr);
  return value;
}
inline bool License_KeyContainer::has_required_protection() const {
  return _internal_has_required_protection();
}
inline void License_KeyContainer::clear_required_protection() {
  if (required_protection_ != nullptr) required_protection_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::_internal_required_protection() const {
  const ::video_widevine::License_KeyContainer_OutputProtection* p = required_protection_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
}
inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::required_protection() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.required_protection)
  return _internal_required_protection();
}
inline void License_KeyContainer::unsafe_arena_set_allocated_required_protection(
    ::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(required_protection_);
  }
  required_protection_ = required_protection;
  if (required_protection) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.required_protection)
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::release_required_protection() {
  _has_bits_[0] &= ~0x00000010u;
  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
  required_protection_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::unsafe_arena_release_required_protection() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.required_protection)
  _has_bits_[0] &= ~0x00000010u;
  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
  required_protection_ = nullptr;
  return temp;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::_internal_mutable_required_protection() {
  _has_bits_[0] |= 0x00000010u;
  if (required_protection_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
    required_protection_ = p;
  }
  return required_protection_;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::mutable_required_protection() {
  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_required_protection();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.required_protection)
  return _msg;
}
inline void License_KeyContainer::set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete required_protection_;
  }
  if (required_protection) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(required_protection);
    if (message_arena != submessage_arena) {
      required_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, required_protection, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  required_protection_ = required_protection;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.required_protection)
}

// optional .video_widevine.License.KeyContainer.OutputProtection requested_protection = 7;
inline bool License_KeyContainer::_internal_has_requested_protection() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || requested_protection_ != nullptr);
  return value;
}
inline bool License_KeyContainer::has_requested_protection() const {
  return _internal_has_requested_protection();
}
inline void License_KeyContainer::clear_requested_protection() {
  if (requested_protection_ != nullptr) requested_protection_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::_internal_requested_protection() const {
  const ::video_widevine::License_KeyContainer_OutputProtection* p = requested_protection_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
}
inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::requested_protection() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.requested_protection)
  return _internal_requested_protection();
}
inline void License_KeyContainer::unsafe_arena_set_allocated_requested_protection(
    ::video_widevine::License_KeyContainer_OutputProtection* requested_protection) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(requested_protection_);
  }
  requested_protection_ = requested_protection;
  if (requested_protection) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.requested_protection)
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::release_requested_protection() {
  _has_bits_[0] &= ~0x00000020u;
  ::video_widevine::License_KeyContainer_OutputProtection* temp = requested_protection_;
  requested_protection_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::unsafe_arena_release_requested_protection() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.requested_protection)
  _has_bits_[0] &= ~0x00000020u;
  ::video_widevine::License_KeyContainer_OutputProtection* temp = requested_protection_;
  requested_protection_ = nullptr;
  return temp;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::_internal_mutable_requested_protection() {
  _has_bits_[0] |= 0x00000020u;
  if (requested_protection_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
    requested_protection_ = p;
  }
  return requested_protection_;
}
inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::mutable_requested_protection() {
  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_requested_protection();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.requested_protection)
  return _msg;
}
inline void License_KeyContainer::set_allocated_requested_protection(::video_widevine::License_KeyContainer_OutputProtection* requested_protection) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete requested_protection_;
  }
  if (requested_protection) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(requested_protection);
    if (message_arena != submessage_arena) {
      requested_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requested_protection, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  requested_protection_ = requested_protection;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.requested_protection)
}

// optional .video_widevine.License.KeyContainer.KeyControl key_control = 8;
inline bool License_KeyContainer::_internal_has_key_control() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || key_control_ != nullptr);
  return value;
}
inline bool License_KeyContainer::has_key_control() const {
  return _internal_has_key_control();
}
inline void License_KeyContainer::clear_key_control() {
  if (key_control_ != nullptr) key_control_->Clear();
  _has_bits_[0] &= ~0x00000040u;
}
inline const ::video_widevine::License_KeyContainer_KeyControl& License_KeyContainer::_internal_key_control() const {
  const ::video_widevine::License_KeyContainer_KeyControl* p = key_control_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_KeyControl&>(
      ::video_widevine::_License_KeyContainer_KeyControl_default_instance_);
}
inline const ::video_widevine::License_KeyContainer_KeyControl& License_KeyContainer::key_control() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key_control)
  return _internal_key_control();
}
inline void License_KeyContainer::unsafe_arena_set_allocated_key_control(
    ::video_widevine::License_KeyContainer_KeyControl* key_control) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_control_);
  }
  key_control_ = key_control;
  if (key_control) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.key_control)
}
inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::release_key_control() {
  _has_bits_[0] &= ~0x00000040u;
  ::video_widevine::License_KeyContainer_KeyControl* temp = key_control_;
  key_control_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::unsafe_arena_release_key_control() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key_control)
  _has_bits_[0] &= ~0x00000040u;
  ::video_widevine::License_KeyContainer_KeyControl* temp = key_control_;
  key_control_ = nullptr;
  return temp;
}
inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::_internal_mutable_key_control() {
  _has_bits_[0] |= 0x00000040u;
  if (key_control_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyControl>(GetArenaForAllocation());
    key_control_ = p;
  }
  return key_control_;
}
inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::mutable_key_control() {
  ::video_widevine::License_KeyContainer_KeyControl* _msg = _internal_mutable_key_control();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key_control)
  return _msg;
}
inline void License_KeyContainer::set_allocated_key_control(::video_widevine::License_KeyContainer_KeyControl* key_control) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete key_control_;
  }
  if (key_control) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_KeyControl>::GetOwningArena(key_control);
    if (message_arena != submessage_arena) {
      key_control = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key_control, submessage_arena);
    }
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  key_control_ = key_control;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key_control)
}

// optional .video_widevine.License.KeyContainer.OperatorSessionKeyPermissions operator_session_key_permissions = 9;
inline bool License_KeyContainer::_internal_has_operator_session_key_permissions() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || operator_session_key_permissions_ != nullptr);
  return value;
}
inline bool License_KeyContainer::has_operator_session_key_permissions() const {
  return _internal_has_operator_session_key_permissions();
}
inline void License_KeyContainer::clear_operator_session_key_permissions() {
  if (operator_session_key_permissions_ != nullptr) operator_session_key_permissions_->Clear();
  _has_bits_[0] &= ~0x00000080u;
}
inline const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& License_KeyContainer::_internal_operator_session_key_permissions() const {
  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* p = operator_session_key_permissions_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions&>(
      ::video_widevine::_License_KeyContainer_OperatorSessionKeyPermissions_default_instance_);
}
inline const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& License_KeyContainer::operator_session_key_permissions() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.operator_session_key_permissions)
  return _internal_operator_session_key_permissions();
}
inline void License_KeyContainer::unsafe_arena_set_allocated_operator_session_key_permissions(
    ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operator_session_key_permissions_);
  }
  operator_session_key_permissions_ = operator_session_key_permissions;
  if (operator_session_key_permissions) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.operator_session_key_permissions)
}
inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::release_operator_session_key_permissions() {
  _has_bits_[0] &= ~0x00000080u;
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* temp = operator_session_key_permissions_;
  operator_session_key_permissions_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::unsafe_arena_release_operator_session_key_permissions() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.operator_session_key_permissions)
  _has_bits_[0] &= ~0x00000080u;
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* temp = operator_session_key_permissions_;
  operator_session_key_permissions_ = nullptr;
  return temp;
}
inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::_internal_mutable_operator_session_key_permissions() {
  _has_bits_[0] |= 0x00000080u;
  if (operator_session_key_permissions_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>(GetArenaForAllocation());
    operator_session_key_permissions_ = p;
  }
  return operator_session_key_permissions_;
}
inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::mutable_operator_session_key_permissions() {
  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* _msg = _internal_mutable_operator_session_key_permissions();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.operator_session_key_permissions)
  return _msg;
}
inline void License_KeyContainer::set_allocated_operator_session_key_permissions(::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete operator_session_key_permissions_;
  }
  if (operator_session_key_permissions) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>::GetOwningArena(operator_session_key_permissions);
    if (message_arena != submessage_arena) {
      operator_session_key_permissions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, operator_session_key_permissions, submessage_arena);
    }
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  operator_session_key_permissions_ = operator_session_key_permissions;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.operator_session_key_permissions)
}

// repeated .video_widevine.License.KeyContainer.VideoResolutionConstraint video_resolution_constraints = 10;
inline int License_KeyContainer::_internal_video_resolution_constraints_size() const {
  return video_resolution_constraints_.size();
}
inline int License_KeyContainer::video_resolution_constraints_size() const {
  return _internal_video_resolution_constraints_size();
}
inline void License_KeyContainer::clear_video_resolution_constraints() {
  video_resolution_constraints_.Clear();
}
inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::mutable_video_resolution_constraints(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.video_resolution_constraints)
  return video_resolution_constraints_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >*
License_KeyContainer::mutable_video_resolution_constraints() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.KeyContainer.video_resolution_constraints)
  return &video_resolution_constraints_;
}
inline const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& License_KeyContainer::_internal_video_resolution_constraints(int index) const {
  return video_resolution_constraints_.Get(index);
}
inline const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& License_KeyContainer::video_resolution_constraints(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.video_resolution_constraints)
  return _internal_video_resolution_constraints(index);
}
inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::_internal_add_video_resolution_constraints() {
  return video_resolution_constraints_.Add();
}
inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::add_video_resolution_constraints() {
  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* _add = _internal_add_video_resolution_constraints();
  // @@protoc_insertion_point(field_add:video_widevine.License.KeyContainer.video_resolution_constraints)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >&
License_KeyContainer::video_resolution_constraints() const {
  // @@protoc_insertion_point(field_list:video_widevine.License.KeyContainer.video_resolution_constraints)
  return video_resolution_constraints_;
}

// optional bool anti_rollback_usage_table = 11 [default = false];
inline bool License_KeyContainer::_internal_has_anti_rollback_usage_table() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool License_KeyContainer::has_anti_rollback_usage_table() const {
  return _internal_has_anti_rollback_usage_table();
}
inline void License_KeyContainer::clear_anti_rollback_usage_table() {
  anti_rollback_usage_table_ = false;
  _has_bits_[0] &= ~0x00000200u;
}
inline bool License_KeyContainer::_internal_anti_rollback_usage_table() const {
  return anti_rollback_usage_table_;
}
inline bool License_KeyContainer::anti_rollback_usage_table() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.anti_rollback_usage_table)
  return _internal_anti_rollback_usage_table();
}
inline void License_KeyContainer::_internal_set_anti_rollback_usage_table(bool value) {
  _has_bits_[0] |= 0x00000200u;
  anti_rollback_usage_table_ = value;
}
inline void License_KeyContainer::set_anti_rollback_usage_table(bool value) {
  _internal_set_anti_rollback_usage_table(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.anti_rollback_usage_table)
}

// optional string track_label = 12;
inline bool License_KeyContainer::_internal_has_track_label() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool License_KeyContainer::has_track_label() const {
  return _internal_has_track_label();
}
inline void License_KeyContainer::clear_track_label() {
  track_label_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& License_KeyContainer::track_label() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.track_label)
  return _internal_track_label();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License_KeyContainer::set_track_label(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 track_label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.track_label)
}
inline std::string* License_KeyContainer::mutable_track_label() {
  std::string* _s = _internal_mutable_track_label();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.track_label)
  return _s;
}
inline const std::string& License_KeyContainer::_internal_track_label() const {
  return track_label_.Get();
}
inline void License_KeyContainer::_internal_set_track_label(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  track_label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::_internal_mutable_track_label() {
  _has_bits_[0] |= 0x00000008u;
  return track_label_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License_KeyContainer::release_track_label() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.track_label)
  if (!_internal_has_track_label()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return track_label_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License_KeyContainer::set_allocated_track_label(std::string* track_label) {
  if (track_label != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  track_label_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), track_label,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.track_label)
}

// optional .video_widevine.License.KeyContainer.KeyCategorySpec key_category_spec = 13;
inline bool License_KeyContainer::_internal_has_key_category_spec() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || key_category_spec_ != nullptr);
  return value;
}
inline bool License_KeyContainer::has_key_category_spec() const {
  return _internal_has_key_category_spec();
}
inline void License_KeyContainer::clear_key_category_spec() {
  if (key_category_spec_ != nullptr) key_category_spec_->Clear();
  _has_bits_[0] &= ~0x00000100u;
}
inline const ::video_widevine::License_KeyContainer_KeyCategorySpec& License_KeyContainer::_internal_key_category_spec() const {
  const ::video_widevine::License_KeyContainer_KeyCategorySpec* p = key_category_spec_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_KeyCategorySpec&>(
      ::video_widevine::_License_KeyContainer_KeyCategorySpec_default_instance_);
}
inline const ::video_widevine::License_KeyContainer_KeyCategorySpec& License_KeyContainer::key_category_spec() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key_category_spec)
  return _internal_key_category_spec();
}
inline void License_KeyContainer::unsafe_arena_set_allocated_key_category_spec(
    ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_category_spec_);
  }
  key_category_spec_ = key_category_spec;
  if (key_category_spec) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.key_category_spec)
}
inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::release_key_category_spec() {
  _has_bits_[0] &= ~0x00000100u;
  ::video_widevine::License_KeyContainer_KeyCategorySpec* temp = key_category_spec_;
  key_category_spec_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::unsafe_arena_release_key_category_spec() {
  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key_category_spec)
  _has_bits_[0] &= ~0x00000100u;
  ::video_widevine::License_KeyContainer_KeyCategorySpec* temp = key_category_spec_;
  key_category_spec_ = nullptr;
  return temp;
}
inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::_internal_mutable_key_category_spec() {
  _has_bits_[0] |= 0x00000100u;
  if (key_category_spec_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyCategorySpec>(GetArenaForAllocation());
    key_category_spec_ = p;
  }
  return key_category_spec_;
}
inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::mutable_key_category_spec() {
  ::video_widevine::License_KeyContainer_KeyCategorySpec* _msg = _internal_mutable_key_category_spec();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key_category_spec)
  return _msg;
}
inline void License_KeyContainer::set_allocated_key_category_spec(::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete key_category_spec_;
  }
  if (key_category_spec) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_KeyCategorySpec>::GetOwningArena(key_category_spec);
    if (message_arena != submessage_arena) {
      key_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key_category_spec, submessage_arena);
    }
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  key_category_spec_ = key_category_spec;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key_category_spec)
}

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

// License

// optional .video_widevine.LicenseIdentification id = 1;
inline bool License::_internal_has_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || id_ != nullptr);
  return value;
}
inline bool License::has_id() const {
  return _internal_has_id();
}
inline void License::clear_id() {
  if (id_ != nullptr) id_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::video_widevine::LicenseIdentification& License::_internal_id() const {
  const ::video_widevine::LicenseIdentification* p = id_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
      ::video_widevine::_LicenseIdentification_default_instance_);
}
inline const ::video_widevine::LicenseIdentification& License::id() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.id)
  return _internal_id();
}
inline void License::unsafe_arena_set_allocated_id(
    ::video_widevine::LicenseIdentification* id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
  }
  id_ = id;
  if (id) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.id)
}
inline ::video_widevine::LicenseIdentification* License::release_id() {
  _has_bits_[0] &= ~0x00000008u;
  ::video_widevine::LicenseIdentification* temp = id_;
  id_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::LicenseIdentification* License::unsafe_arena_release_id() {
  // @@protoc_insertion_point(field_release:video_widevine.License.id)
  _has_bits_[0] &= ~0x00000008u;
  ::video_widevine::LicenseIdentification* temp = id_;
  id_ = nullptr;
  return temp;
}
inline ::video_widevine::LicenseIdentification* License::_internal_mutable_id() {
  _has_bits_[0] |= 0x00000008u;
  if (id_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
    id_ = p;
  }
  return id_;
}
inline ::video_widevine::LicenseIdentification* License::mutable_id() {
  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.id)
  return _msg;
}
inline void License::set_allocated_id(::video_widevine::LicenseIdentification* id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete id_;
  }
  if (id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseIdentification>::GetOwningArena(id);
    if (message_arena != submessage_arena) {
      id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, id, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  id_ = id;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.id)
}

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

// repeated .video_widevine.License.KeyContainer key = 3;
inline int License::_internal_key_size() const {
  return key_.size();
}
inline int License::key_size() const {
  return _internal_key_size();
}
inline void License::clear_key() {
  key_.Clear();
}
inline ::video_widevine::License_KeyContainer* License::mutable_key(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.License.key)
  return key_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >*
License::mutable_key() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.key)
  return &key_;
}
inline const ::video_widevine::License_KeyContainer& License::_internal_key(int index) const {
  return key_.Get(index);
}
inline const ::video_widevine::License_KeyContainer& License::key(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.License.key)
  return _internal_key(index);
}
inline ::video_widevine::License_KeyContainer* License::_internal_add_key() {
  return key_.Add();
}
inline ::video_widevine::License_KeyContainer* License::add_key() {
  ::video_widevine::License_KeyContainer* _add = _internal_add_key();
  // @@protoc_insertion_point(field_add:video_widevine.License.key)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >&
License::key() const {
  // @@protoc_insertion_point(field_list:video_widevine.License.key)
  return key_;
}

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

// optional bool remote_attestation_verified = 5 [default = false];
inline bool License::_internal_has_remote_attestation_verified() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool License::has_remote_attestation_verified() const {
  return _internal_has_remote_attestation_verified();
}
inline void License::clear_remote_attestation_verified() {
  remote_attestation_verified_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool License::_internal_remote_attestation_verified() const {
  return remote_attestation_verified_;
}
inline bool License::remote_attestation_verified() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.remote_attestation_verified)
  return _internal_remote_attestation_verified();
}
inline void License::_internal_set_remote_attestation_verified(bool value) {
  _has_bits_[0] |= 0x00000080u;
  remote_attestation_verified_ = value;
}
inline void License::set_remote_attestation_verified(bool value) {
  _internal_set_remote_attestation_verified(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.remote_attestation_verified)
}

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

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

// optional bytes srm_requirement = 8;
inline bool License::_internal_has_srm_requirement() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool License::has_srm_requirement() const {
  return _internal_has_srm_requirement();
}
inline void License::clear_srm_requirement() {
  srm_requirement_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& License::srm_requirement() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.srm_requirement)
  return _internal_srm_requirement();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License::set_srm_requirement(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 srm_requirement_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.srm_requirement)
}
inline std::string* License::mutable_srm_requirement() {
  std::string* _s = _internal_mutable_srm_requirement();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.srm_requirement)
  return _s;
}
inline const std::string& License::_internal_srm_requirement() const {
  return srm_requirement_.Get();
}
inline void License::_internal_set_srm_requirement(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  srm_requirement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License::_internal_mutable_srm_requirement() {
  _has_bits_[0] |= 0x00000002u;
  return srm_requirement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License::release_srm_requirement() {
  // @@protoc_insertion_point(field_release:video_widevine.License.srm_requirement)
  if (!_internal_has_srm_requirement()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return srm_requirement_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License::set_allocated_srm_requirement(std::string* srm_requirement) {
  if (srm_requirement != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  srm_requirement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), srm_requirement,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.srm_requirement)
}

// optional bytes srm_update = 9;
inline bool License::_internal_has_srm_update() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool License::has_srm_update() const {
  return _internal_has_srm_update();
}
inline void License::clear_srm_update() {
  srm_update_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& License::srm_update() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.srm_update)
  return _internal_srm_update();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void License::set_srm_update(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 srm_update_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.License.srm_update)
}
inline std::string* License::mutable_srm_update() {
  std::string* _s = _internal_mutable_srm_update();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.srm_update)
  return _s;
}
inline const std::string& License::_internal_srm_update() const {
  return srm_update_.Get();
}
inline void License::_internal_set_srm_update(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  srm_update_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* License::_internal_mutable_srm_update() {
  _has_bits_[0] |= 0x00000004u;
  return srm_update_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* License::release_srm_update() {
  // @@protoc_insertion_point(field_release:video_widevine.License.srm_update)
  if (!_internal_has_srm_update()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return srm_update_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void License::set_allocated_srm_update(std::string* srm_update) {
  if (srm_update != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  srm_update_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), srm_update,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.srm_update)
}

// optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
inline bool License::_internal_has_platform_verification_status() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool License::has_platform_verification_status() const {
  return _internal_has_platform_verification_status();
}
inline void License::clear_platform_verification_status() {
  platform_verification_status_ = 4;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::video_widevine::PlatformVerificationStatus License::_internal_platform_verification_status() const {
  return static_cast< ::video_widevine::PlatformVerificationStatus >(platform_verification_status_);
}
inline ::video_widevine::PlatformVerificationStatus License::platform_verification_status() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.platform_verification_status)
  return _internal_platform_verification_status();
}
inline void License::_internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
  _has_bits_[0] |= 0x00000400u;
  platform_verification_status_ = value;
}
inline void License::set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
  _internal_set_platform_verification_status(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.platform_verification_status)
}

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

// optional .video_widevine.LicenseCategorySpec license_category_spec = 12;
inline bool License::_internal_has_license_category_spec() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || license_category_spec_ != nullptr);
  return value;
}
inline bool License::has_license_category_spec() const {
  return _internal_has_license_category_spec();
}
inline void License::clear_license_category_spec() {
  if (license_category_spec_ != nullptr) license_category_spec_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
inline const ::video_widevine::LicenseCategorySpec& License::_internal_license_category_spec() const {
  const ::video_widevine::LicenseCategorySpec* p = license_category_spec_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseCategorySpec&>(
      ::video_widevine::_LicenseCategorySpec_default_instance_);
}
inline const ::video_widevine::LicenseCategorySpec& License::license_category_spec() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.license_category_spec)
  return _internal_license_category_spec();
}
inline void License::unsafe_arena_set_allocated_license_category_spec(
    ::video_widevine::LicenseCategorySpec* license_category_spec) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
  }
  license_category_spec_ = license_category_spec;
  if (license_category_spec) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.license_category_spec)
}
inline ::video_widevine::LicenseCategorySpec* License::release_license_category_spec() {
  _has_bits_[0] &= ~0x00000020u;
  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
  license_category_spec_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::LicenseCategorySpec* License::unsafe_arena_release_license_category_spec() {
  // @@protoc_insertion_point(field_release:video_widevine.License.license_category_spec)
  _has_bits_[0] &= ~0x00000020u;
  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
  license_category_spec_ = nullptr;
  return temp;
}
inline ::video_widevine::LicenseCategorySpec* License::_internal_mutable_license_category_spec() {
  _has_bits_[0] |= 0x00000020u;
  if (license_category_spec_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(GetArenaForAllocation());
    license_category_spec_ = p;
  }
  return license_category_spec_;
}
inline ::video_widevine::LicenseCategorySpec* License::mutable_license_category_spec() {
  ::video_widevine::LicenseCategorySpec* _msg = _internal_mutable_license_category_spec();
  // @@protoc_insertion_point(field_mutable:video_widevine.License.license_category_spec)
  return _msg;
}
inline void License::set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete license_category_spec_;
  }
  if (license_category_spec) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseCategorySpec>::GetOwningArena(license_category_spec);
    if (message_arena != submessage_arena) {
      license_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, license_category_spec, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  license_category_spec_ = license_category_spec;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.license_category_spec)
}

// optional uint32 provider_key_id = 13;
inline bool License::_internal_has_provider_key_id() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool License::has_provider_key_id() const {
  return _internal_has_provider_key_id();
}
inline void License::clear_provider_key_id() {
  provider_key_id_ = 0u;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 License::_internal_provider_key_id() const {
  return provider_key_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 License::provider_key_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.License.provider_key_id)
  return _internal_provider_key_id();
}
inline void License::_internal_set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000200u;
  provider_key_id_ = value;
}
inline void License::set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_provider_key_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.License.provider_key_id)
}

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

// LicenseRequest_ContentIdentification_WidevinePsshData

// repeated bytes pssh_data = 1;
inline int LicenseRequest_ContentIdentification_WidevinePsshData::_internal_pssh_data_size() const {
  return pssh_data_.size();
}
inline int LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data_size() const {
  return _internal_pssh_data_size();
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_pssh_data() {
  pssh_data_.Clear();
}
inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data() {
  std::string* _s = _internal_add_pssh_data();
  // @@protoc_insertion_point(field_add_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::_internal_pssh_data(int index) const {
  return pssh_data_.Get(index);
}
inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
  return _internal_pssh_data(index);
}
inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::mutable_pssh_data(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
  return pssh_data_.Mutable(index);
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const std::string& value) {
  pssh_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, std::string&& value) {
  pssh_data_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  pssh_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const void* value, size_t size) {
  pssh_data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::_internal_add_pssh_data() {
  return pssh_data_.Add();
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const std::string& value) {
  pssh_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(std::string&& value) {
  pssh_data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  pssh_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const void* value, size_t size) {
  pssh_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data() const {
  // @@protoc_insertion_point(field_list:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
  return pssh_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LicenseRequest_ContentIdentification_WidevinePsshData::mutable_pssh_data() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
  return &pssh_data_;
}

// optional .video_widevine.LicenseType license_type = 2;
inline bool LicenseRequest_ContentIdentification_WidevinePsshData::_internal_has_license_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_WidevinePsshData::has_license_type() const {
  return _internal_has_license_type();
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_license_type() {
  license_type_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WidevinePsshData::_internal_license_type() const {
  return static_cast< ::video_widevine::LicenseType >(license_type_);
}
inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WidevinePsshData::license_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.license_type)
  return _internal_license_type();
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::_internal_set_license_type(::video_widevine::LicenseType value) {
  assert(::video_widevine::LicenseType_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  license_type_ = value;
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_license_type(::video_widevine::LicenseType value) {
  _internal_set_license_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.license_type)
}

// optional bytes request_id = 3;
inline bool LicenseRequest_ContentIdentification_WidevinePsshData::_internal_has_request_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_WidevinePsshData::has_request_id() const {
  return _internal_has_request_id();
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_request_id() {
  request_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::request_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
  return _internal_request_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest_ContentIdentification_WidevinePsshData::set_request_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
}
inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::mutable_request_id() {
  std::string* _s = _internal_mutable_request_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::_internal_request_id() const {
  return request_id_.Get();
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::_internal_set_request_id(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::_internal_mutable_request_id() {
  _has_bits_[0] |= 0x00000001u;
  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::release_request_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
  if (!_internal_has_request_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_allocated_request_id(std::string* request_id) {
  if (request_id != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
}

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

// LicenseRequest_ContentIdentification_WebmKeyId

// optional bytes header = 1;
inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_header() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_header() const {
  return _internal_has_header();
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_header() {
  header_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::header() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
  return _internal_header();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest_ContentIdentification_WebmKeyId::set_header(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 header_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
}
inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::mutable_header() {
  std::string* _s = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::_internal_header() const {
  return header_.Get();
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_header(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  header_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::_internal_mutable_header() {
  _has_bits_[0] |= 0x00000001u;
  return header_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::release_header() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
  if (!_internal_has_header()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return header_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::set_allocated_header(std::string* header) {
  if (header != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  header_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), header,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
}

// optional .video_widevine.LicenseType license_type = 2;
inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_license_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_license_type() const {
  return _internal_has_license_type();
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_license_type() {
  license_type_ = 1;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WebmKeyId::_internal_license_type() const {
  return static_cast< ::video_widevine::LicenseType >(license_type_);
}
inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WebmKeyId::license_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.license_type)
  return _internal_license_type();
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_license_type(::video_widevine::LicenseType value) {
  assert(::video_widevine::LicenseType_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  license_type_ = value;
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::set_license_type(::video_widevine::LicenseType value) {
  _internal_set_license_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.license_type)
}

// optional bytes request_id = 3;
inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_request_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_request_id() const {
  return _internal_has_request_id();
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_request_id() {
  request_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::request_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
  return _internal_request_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest_ContentIdentification_WebmKeyId::set_request_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
}
inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::mutable_request_id() {
  std::string* _s = _internal_mutable_request_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::_internal_request_id() const {
  return request_id_.Get();
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_request_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::_internal_mutable_request_id() {
  _has_bits_[0] |= 0x00000002u;
  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::release_request_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
  if (!_internal_has_request_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest_ContentIdentification_WebmKeyId::set_allocated_request_id(std::string* request_id) {
  if (request_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
}

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

// LicenseRequest_ContentIdentification_ExistingLicense

// optional .video_widevine.LicenseIdentification license_id = 1;
inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_license_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || license_id_ != nullptr);
  return value;
}
inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_license_id() const {
  return _internal_has_license_id();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_license_id() {
  if (license_id_ != nullptr) license_id_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::video_widevine::LicenseIdentification& LicenseRequest_ContentIdentification_ExistingLicense::_internal_license_id() const {
  const ::video_widevine::LicenseIdentification* p = license_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
      ::video_widevine::_LicenseIdentification_default_instance_);
}
inline const ::video_widevine::LicenseIdentification& LicenseRequest_ContentIdentification_ExistingLicense::license_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
  return _internal_license_id();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::unsafe_arena_set_allocated_license_id(
    ::video_widevine::LicenseIdentification* license_id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
  }
  license_id_ = license_id;
  if (license_id) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
}
inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::release_license_id() {
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::LicenseIdentification* temp = license_id_;
  license_id_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::unsafe_arena_release_license_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::LicenseIdentification* temp = license_id_;
  license_id_ = nullptr;
  return temp;
}
inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::_internal_mutable_license_id() {
  _has_bits_[0] |= 0x00000002u;
  if (license_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
    license_id_ = p;
  }
  return license_id_;
}
inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::mutable_license_id() {
  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
  return _msg;
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete license_id_;
  }
  if (license_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseIdentification>::GetOwningArena(license_id);
    if (message_arena != submessage_arena) {
      license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, license_id, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  license_id_ = license_id;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
}

// optional int64 seconds_since_started = 2;
inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_seconds_since_started() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_seconds_since_started() const {
  return _internal_has_seconds_since_started();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_seconds_since_started() {
  seconds_since_started_ = int64_t{0};
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::_internal_seconds_since_started() const {
  return seconds_since_started_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::seconds_since_started() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_started)
  return _internal_seconds_since_started();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  seconds_since_started_ = value;
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_seconds_since_started(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_started)
}

// optional int64 seconds_since_last_played = 3;
inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_seconds_since_last_played() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_seconds_since_last_played() const {
  return _internal_has_seconds_since_last_played();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_seconds_since_last_played() {
  seconds_since_last_played_ = int64_t{0};
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::_internal_seconds_since_last_played() const {
  return seconds_since_last_played_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::seconds_since_last_played() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_last_played)
  return _internal_seconds_since_last_played();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  seconds_since_last_played_ = value;
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_seconds_since_last_played(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_last_played)
}

// optional bytes session_usage_table_entry = 4;
inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_session_usage_table_entry() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_session_usage_table_entry() const {
  return _internal_has_session_usage_table_entry();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_session_usage_table_entry() {
  session_usage_table_entry_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LicenseRequest_ContentIdentification_ExistingLicense::session_usage_table_entry() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
  return _internal_session_usage_table_entry();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest_ContentIdentification_ExistingLicense::set_session_usage_table_entry(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 session_usage_table_entry_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
}
inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::mutable_session_usage_table_entry() {
  std::string* _s = _internal_mutable_session_usage_table_entry();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_ExistingLicense::_internal_session_usage_table_entry() const {
  return session_usage_table_entry_.Get();
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_session_usage_table_entry(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  session_usage_table_entry_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::_internal_mutable_session_usage_table_entry() {
  _has_bits_[0] |= 0x00000001u;
  return session_usage_table_entry_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::release_session_usage_table_entry() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
  if (!_internal_has_session_usage_table_entry()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return session_usage_table_entry_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest_ContentIdentification_ExistingLicense::set_allocated_session_usage_table_entry(std::string* session_usage_table_entry) {
  if (session_usage_table_entry != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  session_usage_table_entry_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_usage_table_entry,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
}

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

// LicenseRequest_ContentIdentification_InitData

// optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1 [default = CENC];
inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_init_data_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_InitData::has_init_data_type() const {
  return _internal_has_init_data_type();
}
inline void LicenseRequest_ContentIdentification_InitData::clear_init_data_type() {
  init_data_type_ = 1;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData::_internal_init_data_type() const {
  return static_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType >(init_data_type_);
}
inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData::init_data_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data_type)
  return _internal_init_data_type();
}
inline void LicenseRequest_ContentIdentification_InitData::_internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
  assert(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  init_data_type_ = value;
}
inline void LicenseRequest_ContentIdentification_InitData::set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
  _internal_set_init_data_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data_type)
}

// optional bytes init_data = 2;
inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_init_data() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_InitData::has_init_data() const {
  return _internal_has_init_data();
}
inline void LicenseRequest_ContentIdentification_InitData::clear_init_data() {
  init_data_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LicenseRequest_ContentIdentification_InitData::init_data() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
  return _internal_init_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest_ContentIdentification_InitData::set_init_data(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 init_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
}
inline std::string* LicenseRequest_ContentIdentification_InitData::mutable_init_data() {
  std::string* _s = _internal_mutable_init_data();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_InitData::_internal_init_data() const {
  return init_data_.Get();
}
inline void LicenseRequest_ContentIdentification_InitData::_internal_set_init_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  init_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_InitData::_internal_mutable_init_data() {
  _has_bits_[0] |= 0x00000001u;
  return init_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_InitData::release_init_data() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
  if (!_internal_has_init_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return init_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest_ContentIdentification_InitData::set_allocated_init_data(std::string* init_data) {
  if (init_data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  init_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), init_data,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
}

// optional .video_widevine.LicenseType license_type = 3;
inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_license_type() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_InitData::has_license_type() const {
  return _internal_has_license_type();
}
inline void LicenseRequest_ContentIdentification_InitData::clear_license_type() {
  license_type_ = 1;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_InitData::_internal_license_type() const {
  return static_cast< ::video_widevine::LicenseType >(license_type_);
}
inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_InitData::license_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.license_type)
  return _internal_license_type();
}
inline void LicenseRequest_ContentIdentification_InitData::_internal_set_license_type(::video_widevine::LicenseType value) {
  assert(::video_widevine::LicenseType_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  license_type_ = value;
}
inline void LicenseRequest_ContentIdentification_InitData::set_license_type(::video_widevine::LicenseType value) {
  _internal_set_license_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.license_type)
}

// optional bytes request_id = 4;
inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_request_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LicenseRequest_ContentIdentification_InitData::has_request_id() const {
  return _internal_has_request_id();
}
inline void LicenseRequest_ContentIdentification_InitData::clear_request_id() {
  request_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LicenseRequest_ContentIdentification_InitData::request_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
  return _internal_request_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest_ContentIdentification_InitData::set_request_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
}
inline std::string* LicenseRequest_ContentIdentification_InitData::mutable_request_id() {
  std::string* _s = _internal_mutable_request_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
  return _s;
}
inline const std::string& LicenseRequest_ContentIdentification_InitData::_internal_request_id() const {
  return request_id_.Get();
}
inline void LicenseRequest_ContentIdentification_InitData::_internal_set_request_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_InitData::_internal_mutable_request_id() {
  _has_bits_[0] |= 0x00000002u;
  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest_ContentIdentification_InitData::release_request_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
  if (!_internal_has_request_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest_ContentIdentification_InitData::set_allocated_request_id(std::string* request_id) {
  if (request_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
}

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

// LicenseRequest_ContentIdentification

// .video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData widevine_pssh_data = 1;
inline bool LicenseRequest_ContentIdentification::_internal_has_widevine_pssh_data() const {
  return content_id_variant_case() == kWidevinePsshData;
}
inline bool LicenseRequest_ContentIdentification::has_widevine_pssh_data() const {
  return _internal_has_widevine_pssh_data();
}
inline void LicenseRequest_ContentIdentification::set_has_widevine_pssh_data() {
  _oneof_case_[0] = kWidevinePsshData;
}
inline void LicenseRequest_ContentIdentification::clear_widevine_pssh_data() {
  if (_internal_has_widevine_pssh_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete content_id_variant_.widevine_pssh_data_;
    }
    clear_has_content_id_variant();
  }
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::release_widevine_pssh_data() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
  if (_internal_has_widevine_pssh_data()) {
    clear_has_content_id_variant();
      ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* temp = content_id_variant_.widevine_pssh_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    content_id_variant_.widevine_pssh_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& LicenseRequest_ContentIdentification::_internal_widevine_pssh_data() const {
  return _internal_has_widevine_pssh_data()
      ? *content_id_variant_.widevine_pssh_data_
      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData&>(::video_widevine::_LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_);
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& LicenseRequest_ContentIdentification::widevine_pssh_data() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
  return _internal_widevine_pssh_data();
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::unsafe_arena_release_widevine_pssh_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
  if (_internal_has_widevine_pssh_data()) {
    clear_has_content_id_variant();
    ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* temp = content_id_variant_.widevine_pssh_data_;
    content_id_variant_.widevine_pssh_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_widevine_pssh_data(::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data) {
  clear_content_id_variant();
  if (widevine_pssh_data) {
    set_has_widevine_pssh_data();
    content_id_variant_.widevine_pssh_data_ = widevine_pssh_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::_internal_mutable_widevine_pssh_data() {
  if (!_internal_has_widevine_pssh_data()) {
    clear_content_id_variant();
    set_has_widevine_pssh_data();
    content_id_variant_.widevine_pssh_data_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData >(GetArenaForAllocation());
  }
  return content_id_variant_.widevine_pssh_data_;
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::mutable_widevine_pssh_data() {
  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* _msg = _internal_mutable_widevine_pssh_data();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
  return _msg;
}

// .video_widevine.LicenseRequest.ContentIdentification.WebmKeyId webm_key_id = 2;
inline bool LicenseRequest_ContentIdentification::_internal_has_webm_key_id() const {
  return content_id_variant_case() == kWebmKeyId;
}
inline bool LicenseRequest_ContentIdentification::has_webm_key_id() const {
  return _internal_has_webm_key_id();
}
inline void LicenseRequest_ContentIdentification::set_has_webm_key_id() {
  _oneof_case_[0] = kWebmKeyId;
}
inline void LicenseRequest_ContentIdentification::clear_webm_key_id() {
  if (_internal_has_webm_key_id()) {
    if (GetArenaForAllocation() == nullptr) {
      delete content_id_variant_.webm_key_id_;
    }
    clear_has_content_id_variant();
  }
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::release_webm_key_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
  if (_internal_has_webm_key_id()) {
    clear_has_content_id_variant();
      ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* temp = content_id_variant_.webm_key_id_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    content_id_variant_.webm_key_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& LicenseRequest_ContentIdentification::_internal_webm_key_id() const {
  return _internal_has_webm_key_id()
      ? *content_id_variant_.webm_key_id_
      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId&>(::video_widevine::_LicenseRequest_ContentIdentification_WebmKeyId_default_instance_);
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& LicenseRequest_ContentIdentification::webm_key_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
  return _internal_webm_key_id();
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::unsafe_arena_release_webm_key_id() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
  if (_internal_has_webm_key_id()) {
    clear_has_content_id_variant();
    ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* temp = content_id_variant_.webm_key_id_;
    content_id_variant_.webm_key_id_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_webm_key_id(::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id) {
  clear_content_id_variant();
  if (webm_key_id) {
    set_has_webm_key_id();
    content_id_variant_.webm_key_id_ = webm_key_id;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::_internal_mutable_webm_key_id() {
  if (!_internal_has_webm_key_id()) {
    clear_content_id_variant();
    set_has_webm_key_id();
    content_id_variant_.webm_key_id_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId >(GetArenaForAllocation());
  }
  return content_id_variant_.webm_key_id_;
}
inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::mutable_webm_key_id() {
  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* _msg = _internal_mutable_webm_key_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
  return _msg;
}

// .video_widevine.LicenseRequest.ContentIdentification.ExistingLicense existing_license = 3;
inline bool LicenseRequest_ContentIdentification::_internal_has_existing_license() const {
  return content_id_variant_case() == kExistingLicense;
}
inline bool LicenseRequest_ContentIdentification::has_existing_license() const {
  return _internal_has_existing_license();
}
inline void LicenseRequest_ContentIdentification::set_has_existing_license() {
  _oneof_case_[0] = kExistingLicense;
}
inline void LicenseRequest_ContentIdentification::clear_existing_license() {
  if (_internal_has_existing_license()) {
    if (GetArenaForAllocation() == nullptr) {
      delete content_id_variant_.existing_license_;
    }
    clear_has_content_id_variant();
  }
}
inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::release_existing_license() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.existing_license)
  if (_internal_has_existing_license()) {
    clear_has_content_id_variant();
      ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* temp = content_id_variant_.existing_license_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    content_id_variant_.existing_license_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& LicenseRequest_ContentIdentification::_internal_existing_license() const {
  return _internal_has_existing_license()
      ? *content_id_variant_.existing_license_
      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense&>(::video_widevine::_LicenseRequest_ContentIdentification_ExistingLicense_default_instance_);
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& LicenseRequest_ContentIdentification::existing_license() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.existing_license)
  return _internal_existing_license();
}
inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::unsafe_arena_release_existing_license() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.existing_license)
  if (_internal_has_existing_license()) {
    clear_has_content_id_variant();
    ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* temp = content_id_variant_.existing_license_;
    content_id_variant_.existing_license_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_existing_license(::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license) {
  clear_content_id_variant();
  if (existing_license) {
    set_has_existing_license();
    content_id_variant_.existing_license_ = existing_license;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.existing_license)
}
inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::_internal_mutable_existing_license() {
  if (!_internal_has_existing_license()) {
    clear_content_id_variant();
    set_has_existing_license();
    content_id_variant_.existing_license_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense >(GetArenaForAllocation());
  }
  return content_id_variant_.existing_license_;
}
inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::mutable_existing_license() {
  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* _msg = _internal_mutable_existing_license();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.existing_license)
  return _msg;
}

// .video_widevine.LicenseRequest.ContentIdentification.InitData init_data = 4;
inline bool LicenseRequest_ContentIdentification::_internal_has_init_data() const {
  return content_id_variant_case() == kInitData;
}
inline bool LicenseRequest_ContentIdentification::has_init_data() const {
  return _internal_has_init_data();
}
inline void LicenseRequest_ContentIdentification::set_has_init_data() {
  _oneof_case_[0] = kInitData;
}
inline void LicenseRequest_ContentIdentification::clear_init_data() {
  if (_internal_has_init_data()) {
    if (GetArenaForAllocation() == nullptr) {
      delete content_id_variant_.init_data_;
    }
    clear_has_content_id_variant();
  }
}
inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::release_init_data() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.init_data)
  if (_internal_has_init_data()) {
    clear_has_content_id_variant();
      ::video_widevine::LicenseRequest_ContentIdentification_InitData* temp = content_id_variant_.init_data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    content_id_variant_.init_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_InitData& LicenseRequest_ContentIdentification::_internal_init_data() const {
  return _internal_has_init_data()
      ? *content_id_variant_.init_data_
      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData&>(::video_widevine::_LicenseRequest_ContentIdentification_InitData_default_instance_);
}
inline const ::video_widevine::LicenseRequest_ContentIdentification_InitData& LicenseRequest_ContentIdentification::init_data() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.init_data)
  return _internal_init_data();
}
inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::unsafe_arena_release_init_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.init_data)
  if (_internal_has_init_data()) {
    clear_has_content_id_variant();
    ::video_widevine::LicenseRequest_ContentIdentification_InitData* temp = content_id_variant_.init_data_;
    content_id_variant_.init_data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_init_data(::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data) {
  clear_content_id_variant();
  if (init_data) {
    set_has_init_data();
    content_id_variant_.init_data_ = init_data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.init_data)
}
inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::_internal_mutable_init_data() {
  if (!_internal_has_init_data()) {
    clear_content_id_variant();
    set_has_init_data();
    content_id_variant_.init_data_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_InitData >(GetArenaForAllocation());
  }
  return content_id_variant_.init_data_;
}
inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::mutable_init_data() {
  ::video_widevine::LicenseRequest_ContentIdentification_InitData* _msg = _internal_mutable_init_data();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.init_data)
  return _msg;
}

inline bool LicenseRequest_ContentIdentification::has_content_id_variant() const {
  return content_id_variant_case() != CONTENT_ID_VARIANT_NOT_SET;
}
inline void LicenseRequest_ContentIdentification::clear_has_content_id_variant() {
  _oneof_case_[0] = CONTENT_ID_VARIANT_NOT_SET;
}
inline LicenseRequest_ContentIdentification::ContentIdVariantCase LicenseRequest_ContentIdentification::content_id_variant_case() const {
  return LicenseRequest_ContentIdentification::ContentIdVariantCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// LicenseRequest

// optional .video_widevine.ClientIdentification client_id = 1;
inline bool LicenseRequest::_internal_has_client_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || client_id_ != nullptr);
  return value;
}
inline bool LicenseRequest::has_client_id() const {
  return _internal_has_client_id();
}
inline const ::video_widevine::ClientIdentification& LicenseRequest::_internal_client_id() const {
  const ::video_widevine::ClientIdentification* p = client_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification&>(
      ::video_widevine::_ClientIdentification_default_instance_);
}
inline const ::video_widevine::ClientIdentification& LicenseRequest::client_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.client_id)
  return _internal_client_id();
}
inline void LicenseRequest::unsafe_arena_set_allocated_client_id(
    ::video_widevine::ClientIdentification* client_id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id_);
  }
  client_id_ = client_id;
  if (client_id) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.client_id)
}
inline ::video_widevine::ClientIdentification* LicenseRequest::release_client_id() {
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::ClientIdentification* temp = client_id_;
  client_id_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::ClientIdentification* LicenseRequest::unsafe_arena_release_client_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.client_id)
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::ClientIdentification* temp = client_id_;
  client_id_ = nullptr;
  return temp;
}
inline ::video_widevine::ClientIdentification* LicenseRequest::_internal_mutable_client_id() {
  _has_bits_[0] |= 0x00000002u;
  if (client_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification>(GetArenaForAllocation());
    client_id_ = p;
  }
  return client_id_;
}
inline ::video_widevine::ClientIdentification* LicenseRequest::mutable_client_id() {
  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.client_id)
  return _msg;
}
inline void LicenseRequest::set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id_);
  }
  if (client_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id));
    if (message_arena != submessage_arena) {
      client_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, client_id, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  client_id_ = client_id;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.client_id)
}

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

// optional .video_widevine.LicenseRequest.RequestType type = 3;
inline bool LicenseRequest::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool LicenseRequest::has_type() const {
  return _internal_has_type();
}
inline void LicenseRequest::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::video_widevine::LicenseRequest_RequestType LicenseRequest::_internal_type() const {
  return static_cast< ::video_widevine::LicenseRequest_RequestType >(type_);
}
inline ::video_widevine::LicenseRequest_RequestType LicenseRequest::type() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.type)
  return _internal_type();
}
inline void LicenseRequest::_internal_set_type(::video_widevine::LicenseRequest_RequestType value) {
  assert(::video_widevine::LicenseRequest_RequestType_IsValid(value));
  _has_bits_[0] |= 0x00000040u;
  type_ = value;
}
inline void LicenseRequest::set_type(::video_widevine::LicenseRequest_RequestType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.type)
}

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

// optional bytes key_control_nonce_deprecated = 5;
inline bool LicenseRequest::_internal_has_key_control_nonce_deprecated() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseRequest::has_key_control_nonce_deprecated() const {
  return _internal_has_key_control_nonce_deprecated();
}
inline void LicenseRequest::clear_key_control_nonce_deprecated() {
  key_control_nonce_deprecated_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LicenseRequest::key_control_nonce_deprecated() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.key_control_nonce_deprecated)
  return _internal_key_control_nonce_deprecated();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LicenseRequest::set_key_control_nonce_deprecated(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 key_control_nonce_deprecated_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.key_control_nonce_deprecated)
}
inline std::string* LicenseRequest::mutable_key_control_nonce_deprecated() {
  std::string* _s = _internal_mutable_key_control_nonce_deprecated();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.key_control_nonce_deprecated)
  return _s;
}
inline const std::string& LicenseRequest::_internal_key_control_nonce_deprecated() const {
  return key_control_nonce_deprecated_.Get();
}
inline void LicenseRequest::_internal_set_key_control_nonce_deprecated(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  key_control_nonce_deprecated_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LicenseRequest::_internal_mutable_key_control_nonce_deprecated() {
  _has_bits_[0] |= 0x00000001u;
  return key_control_nonce_deprecated_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LicenseRequest::release_key_control_nonce_deprecated() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.key_control_nonce_deprecated)
  if (!_internal_has_key_control_nonce_deprecated()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return key_control_nonce_deprecated_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LicenseRequest::set_allocated_key_control_nonce_deprecated(std::string* key_control_nonce_deprecated) {
  if (key_control_nonce_deprecated != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  key_control_nonce_deprecated_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_control_nonce_deprecated,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.key_control_nonce_deprecated)
}

// optional .video_widevine.ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
inline bool LicenseRequest::_internal_has_protocol_version() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool LicenseRequest::has_protocol_version() const {
  return _internal_has_protocol_version();
}
inline void LicenseRequest::clear_protocol_version() {
  protocol_version_ = 20;
  _has_bits_[0] &= ~0x00000080u;
}
inline ::video_widevine::ProtocolVersion LicenseRequest::_internal_protocol_version() const {
  return static_cast< ::video_widevine::ProtocolVersion >(protocol_version_);
}
inline ::video_widevine::ProtocolVersion LicenseRequest::protocol_version() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.protocol_version)
  return _internal_protocol_version();
}
inline void LicenseRequest::_internal_set_protocol_version(::video_widevine::ProtocolVersion value) {
  assert(::video_widevine::ProtocolVersion_IsValid(value));
  _has_bits_[0] |= 0x00000080u;
  protocol_version_ = value;
}
inline void LicenseRequest::set_protocol_version(::video_widevine::ProtocolVersion value) {
  _internal_set_protocol_version(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.protocol_version)
}

// optional uint32 key_control_nonce = 7;
inline bool LicenseRequest::_internal_has_key_control_nonce() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool LicenseRequest::has_key_control_nonce() const {
  return _internal_has_key_control_nonce();
}
inline void LicenseRequest::clear_key_control_nonce() {
  key_control_nonce_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LicenseRequest::_internal_key_control_nonce() const {
  return key_control_nonce_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LicenseRequest::key_control_nonce() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.key_control_nonce)
  return _internal_key_control_nonce();
}
inline void LicenseRequest::_internal_set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  key_control_nonce_ = value;
}
inline void LicenseRequest::set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_key_control_nonce(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.key_control_nonce)
}

// optional .video_widevine.EncryptedClientIdentification encrypted_client_id = 8;
inline bool LicenseRequest::_internal_has_encrypted_client_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || encrypted_client_id_ != nullptr);
  return value;
}
inline bool LicenseRequest::has_encrypted_client_id() const {
  return _internal_has_encrypted_client_id();
}
inline const ::video_widevine::EncryptedClientIdentification& LicenseRequest::_internal_encrypted_client_id() const {
  const ::video_widevine::EncryptedClientIdentification* p = encrypted_client_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::EncryptedClientIdentification&>(
      ::video_widevine::_EncryptedClientIdentification_default_instance_);
}
inline const ::video_widevine::EncryptedClientIdentification& LicenseRequest::encrypted_client_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.encrypted_client_id)
  return _internal_encrypted_client_id();
}
inline void LicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(
    ::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id_);
  }
  encrypted_client_id_ = encrypted_client_id;
  if (encrypted_client_id) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.encrypted_client_id)
}
inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::release_encrypted_client_id() {
  _has_bits_[0] &= ~0x00000008u;
  ::video_widevine::EncryptedClientIdentification* temp = encrypted_client_id_;
  encrypted_client_id_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::unsafe_arena_release_encrypted_client_id() {
  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.encrypted_client_id)
  _has_bits_[0] &= ~0x00000008u;
  ::video_widevine::EncryptedClientIdentification* temp = encrypted_client_id_;
  encrypted_client_id_ = nullptr;
  return temp;
}
inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::_internal_mutable_encrypted_client_id() {
  _has_bits_[0] |= 0x00000008u;
  if (encrypted_client_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(GetArenaForAllocation());
    encrypted_client_id_ = p;
  }
  return encrypted_client_id_;
}
inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::mutable_encrypted_client_id() {
  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.encrypted_client_id)
  return _msg;
}
inline void LicenseRequest::set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id_);
  }
  if (encrypted_client_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id));
    if (message_arena != submessage_arena) {
      encrypted_client_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, encrypted_client_id, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  encrypted_client_id_ = encrypted_client_id;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.encrypted_client_id)
}

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

// LicenseError

// optional .video_widevine.LicenseError.Error error_code = 1;
inline bool LicenseError::_internal_has_error_code() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LicenseError::has_error_code() const {
  return _internal_has_error_code();
}
inline void LicenseError::clear_error_code() {
  error_code_ = 1;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::video_widevine::LicenseError_Error LicenseError::_internal_error_code() const {
  return static_cast< ::video_widevine::LicenseError_Error >(error_code_);
}
inline ::video_widevine::LicenseError_Error LicenseError::error_code() const {
  // @@protoc_insertion_point(field_get:video_widevine.LicenseError.error_code)
  return _internal_error_code();
}
inline void LicenseError::_internal_set_error_code(::video_widevine::LicenseError_Error value) {
  assert(::video_widevine::LicenseError_Error_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  error_code_ = value;
}
inline void LicenseError::set_error_code(::video_widevine::LicenseError_Error value) {
  _internal_set_error_code(value);
  // @@protoc_insertion_point(field_set:video_widevine.LicenseError.error_code)
}

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

// MetricData_TypeValue

// optional .video_widevine.MetricData.MetricType type = 1;
inline bool MetricData_TypeValue::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MetricData_TypeValue::has_type() const {
  return _internal_has_type();
}
inline void MetricData_TypeValue::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::video_widevine::MetricData_MetricType MetricData_TypeValue::_internal_type() const {
  return static_cast< ::video_widevine::MetricData_MetricType >(type_);
}
inline ::video_widevine::MetricData_MetricType MetricData_TypeValue::type() const {
  // @@protoc_insertion_point(field_get:video_widevine.MetricData.TypeValue.type)
  return _internal_type();
}
inline void MetricData_TypeValue::_internal_set_type(::video_widevine::MetricData_MetricType value) {
  assert(::video_widevine::MetricData_MetricType_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  type_ = value;
}
inline void MetricData_TypeValue::set_type(::video_widevine::MetricData_MetricType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.MetricData.TypeValue.type)
}

// optional int64 value = 2 [default = 0];
inline bool MetricData_TypeValue::_internal_has_value() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MetricData_TypeValue::has_value() const {
  return _internal_has_value();
}
inline void MetricData_TypeValue::clear_value() {
  value_ = int64_t{0};
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MetricData_TypeValue::_internal_value() const {
  return value_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MetricData_TypeValue::value() const {
  // @@protoc_insertion_point(field_get:video_widevine.MetricData.TypeValue.value)
  return _internal_value();
}
inline void MetricData_TypeValue::_internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  value_ = value;
}
inline void MetricData_TypeValue::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:video_widevine.MetricData.TypeValue.value)
}

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

// MetricData

// optional string stage_name = 1;
inline bool MetricData::_internal_has_stage_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MetricData::has_stage_name() const {
  return _internal_has_stage_name();
}
inline void MetricData::clear_stage_name() {
  stage_name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MetricData::stage_name() const {
  // @@protoc_insertion_point(field_get:video_widevine.MetricData.stage_name)
  return _internal_stage_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricData::set_stage_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 stage_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.MetricData.stage_name)
}
inline std::string* MetricData::mutable_stage_name() {
  std::string* _s = _internal_mutable_stage_name();
  // @@protoc_insertion_point(field_mutable:video_widevine.MetricData.stage_name)
  return _s;
}
inline const std::string& MetricData::_internal_stage_name() const {
  return stage_name_.Get();
}
inline void MetricData::_internal_set_stage_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  stage_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MetricData::_internal_mutable_stage_name() {
  _has_bits_[0] |= 0x00000001u;
  return stage_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MetricData::release_stage_name() {
  // @@protoc_insertion_point(field_release:video_widevine.MetricData.stage_name)
  if (!_internal_has_stage_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return stage_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void MetricData::set_allocated_stage_name(std::string* stage_name) {
  if (stage_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  stage_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stage_name,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.MetricData.stage_name)
}

// repeated .video_widevine.MetricData.TypeValue metric_data = 2;
inline int MetricData::_internal_metric_data_size() const {
  return metric_data_.size();
}
inline int MetricData::metric_data_size() const {
  return _internal_metric_data_size();
}
inline void MetricData::clear_metric_data() {
  metric_data_.Clear();
}
inline ::video_widevine::MetricData_TypeValue* MetricData::mutable_metric_data(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.MetricData.metric_data)
  return metric_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >*
MetricData::mutable_metric_data() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.MetricData.metric_data)
  return &metric_data_;
}
inline const ::video_widevine::MetricData_TypeValue& MetricData::_internal_metric_data(int index) const {
  return metric_data_.Get(index);
}
inline const ::video_widevine::MetricData_TypeValue& MetricData::metric_data(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.MetricData.metric_data)
  return _internal_metric_data(index);
}
inline ::video_widevine::MetricData_TypeValue* MetricData::_internal_add_metric_data() {
  return metric_data_.Add();
}
inline ::video_widevine::MetricData_TypeValue* MetricData::add_metric_data() {
  ::video_widevine::MetricData_TypeValue* _add = _internal_add_metric_data();
  // @@protoc_insertion_point(field_add:video_widevine.MetricData.metric_data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >&
MetricData::metric_data() const {
  // @@protoc_insertion_point(field_list:video_widevine.MetricData.metric_data)
  return metric_data_;
}

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

// VersionInfo

// optional string license_sdk_version = 1;
inline bool VersionInfo::_internal_has_license_sdk_version() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool VersionInfo::has_license_sdk_version() const {
  return _internal_has_license_sdk_version();
}
inline void VersionInfo::clear_license_sdk_version() {
  license_sdk_version_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& VersionInfo::license_sdk_version() const {
  // @@protoc_insertion_point(field_get:video_widevine.VersionInfo.license_sdk_version)
  return _internal_license_sdk_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VersionInfo::set_license_sdk_version(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 license_sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.VersionInfo.license_sdk_version)
}
inline std::string* VersionInfo::mutable_license_sdk_version() {
  std::string* _s = _internal_mutable_license_sdk_version();
  // @@protoc_insertion_point(field_mutable:video_widevine.VersionInfo.license_sdk_version)
  return _s;
}
inline const std::string& VersionInfo::_internal_license_sdk_version() const {
  return license_sdk_version_.Get();
}
inline void VersionInfo::_internal_set_license_sdk_version(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  license_sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* VersionInfo::_internal_mutable_license_sdk_version() {
  _has_bits_[0] |= 0x00000001u;
  return license_sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* VersionInfo::release_license_sdk_version() {
  // @@protoc_insertion_point(field_release:video_widevine.VersionInfo.license_sdk_version)
  if (!_internal_has_license_sdk_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return license_sdk_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void VersionInfo::set_allocated_license_sdk_version(std::string* license_sdk_version) {
  if (license_sdk_version != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  license_sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license_sdk_version,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.VersionInfo.license_sdk_version)
}

// optional string license_service_version = 2;
inline bool VersionInfo::_internal_has_license_service_version() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool VersionInfo::has_license_service_version() const {
  return _internal_has_license_service_version();
}
inline void VersionInfo::clear_license_service_version() {
  license_service_version_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& VersionInfo::license_service_version() const {
  // @@protoc_insertion_point(field_get:video_widevine.VersionInfo.license_service_version)
  return _internal_license_service_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VersionInfo::set_license_service_version(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 license_service_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.VersionInfo.license_service_version)
}
inline std::string* VersionInfo::mutable_license_service_version() {
  std::string* _s = _internal_mutable_license_service_version();
  // @@protoc_insertion_point(field_mutable:video_widevine.VersionInfo.license_service_version)
  return _s;
}
inline const std::string& VersionInfo::_internal_license_service_version() const {
  return license_service_version_.Get();
}
inline void VersionInfo::_internal_set_license_service_version(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  license_service_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* VersionInfo::_internal_mutable_license_service_version() {
  _has_bits_[0] |= 0x00000002u;
  return license_service_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* VersionInfo::release_license_service_version() {
  // @@protoc_insertion_point(field_release:video_widevine.VersionInfo.license_service_version)
  if (!_internal_has_license_service_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return license_service_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void VersionInfo::set_allocated_license_service_version(std::string* license_service_version) {
  if (license_service_version != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  license_service_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license_service_version,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.VersionInfo.license_service_version)
}

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

// SignedMessage

// optional .video_widevine.SignedMessage.MessageType type = 1;
inline bool SignedMessage::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SignedMessage::has_type() const {
  return _internal_has_type();
}
inline void SignedMessage::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::video_widevine::SignedMessage_MessageType SignedMessage::_internal_type() const {
  return static_cast< ::video_widevine::SignedMessage_MessageType >(type_);
}
inline ::video_widevine::SignedMessage_MessageType SignedMessage::type() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.type)
  return _internal_type();
}
inline void SignedMessage::_internal_set_type(::video_widevine::SignedMessage_MessageType value) {
  assert(::video_widevine::SignedMessage_MessageType_IsValid(value));
  _has_bits_[0] |= 0x00000100u;
  type_ = value;
}
inline void SignedMessage::set_type(::video_widevine::SignedMessage_MessageType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.type)
}

// optional bytes msg = 2;
inline bool SignedMessage::_internal_has_msg() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SignedMessage::has_msg() const {
  return _internal_has_msg();
}
inline void SignedMessage::clear_msg() {
  msg_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SignedMessage::msg() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedMessage::set_msg(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 msg_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.msg)
}
inline std::string* SignedMessage::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.msg)
  return _s;
}
inline const std::string& SignedMessage::_internal_msg() const {
  return msg_.Get();
}
inline void SignedMessage::_internal_set_msg(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  msg_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SignedMessage::_internal_mutable_msg() {
  _has_bits_[0] |= 0x00000001u;
  return msg_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SignedMessage::release_msg() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.msg)
  if (!_internal_has_msg()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return msg_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SignedMessage::set_allocated_msg(std::string* msg) {
  if (msg != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  msg_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.msg)
}

// optional bytes signature = 3;
inline bool SignedMessage::_internal_has_signature() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SignedMessage::has_signature() const {
  return _internal_has_signature();
}
inline void SignedMessage::clear_signature() {
  signature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SignedMessage::signature() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedMessage::set_signature(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.signature)
}
inline std::string* SignedMessage::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.signature)
  return _s;
}
inline const std::string& SignedMessage::_internal_signature() const {
  return signature_.Get();
}
inline void SignedMessage::_internal_set_signature(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SignedMessage::_internal_mutable_signature() {
  _has_bits_[0] |= 0x00000002u;
  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SignedMessage::release_signature() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SignedMessage::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.signature)
}

// optional bytes session_key = 4;
inline bool SignedMessage::_internal_has_session_key() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SignedMessage::has_session_key() const {
  return _internal_has_session_key();
}
inline void SignedMessage::clear_session_key() {
  session_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SignedMessage::session_key() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.session_key)
  return _internal_session_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedMessage::set_session_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 session_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.session_key)
}
inline std::string* SignedMessage::mutable_session_key() {
  std::string* _s = _internal_mutable_session_key();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.session_key)
  return _s;
}
inline const std::string& SignedMessage::_internal_session_key() const {
  return session_key_.Get();
}
inline void SignedMessage::_internal_set_session_key(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  session_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SignedMessage::_internal_mutable_session_key() {
  _has_bits_[0] |= 0x00000004u;
  return session_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SignedMessage::release_session_key() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.session_key)
  if (!_internal_has_session_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return session_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SignedMessage::set_allocated_session_key(std::string* session_key) {
  if (session_key != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  session_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_key,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.session_key)
}

// optional .video_widevine.RemoteAttestation remote_attestation = 5;
inline bool SignedMessage::_internal_has_remote_attestation() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || remote_attestation_ != nullptr);
  return value;
}
inline bool SignedMessage::has_remote_attestation() const {
  return _internal_has_remote_attestation();
}
inline const ::video_widevine::RemoteAttestation& SignedMessage::_internal_remote_attestation() const {
  const ::video_widevine::RemoteAttestation* p = remote_attestation_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RemoteAttestation&>(
      ::video_widevine::_RemoteAttestation_default_instance_);
}
inline const ::video_widevine::RemoteAttestation& SignedMessage::remote_attestation() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.remote_attestation)
  return _internal_remote_attestation();
}
inline void SignedMessage::unsafe_arena_set_allocated_remote_attestation(
    ::video_widevine::RemoteAttestation* remote_attestation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
  }
  remote_attestation_ = remote_attestation;
  if (remote_attestation) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedMessage.remote_attestation)
}
inline ::video_widevine::RemoteAttestation* SignedMessage::release_remote_attestation() {
  _has_bits_[0] &= ~0x00000010u;
  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
  remote_attestation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::RemoteAttestation* SignedMessage::unsafe_arena_release_remote_attestation() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.remote_attestation)
  _has_bits_[0] &= ~0x00000010u;
  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
  remote_attestation_ = nullptr;
  return temp;
}
inline ::video_widevine::RemoteAttestation* SignedMessage::_internal_mutable_remote_attestation() {
  _has_bits_[0] |= 0x00000010u;
  if (remote_attestation_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::RemoteAttestation>(GetArenaForAllocation());
    remote_attestation_ = p;
  }
  return remote_attestation_;
}
inline ::video_widevine::RemoteAttestation* SignedMessage::mutable_remote_attestation() {
  ::video_widevine::RemoteAttestation* _msg = _internal_mutable_remote_attestation();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.remote_attestation)
  return _msg;
}
inline void SignedMessage::set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
  }
  if (remote_attestation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation));
    if (message_arena != submessage_arena) {
      remote_attestation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remote_attestation, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  remote_attestation_ = remote_attestation;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.remote_attestation)
}

// repeated .video_widevine.MetricData metric_data = 6;
inline int SignedMessage::_internal_metric_data_size() const {
  return metric_data_.size();
}
inline int SignedMessage::metric_data_size() const {
  return _internal_metric_data_size();
}
inline void SignedMessage::clear_metric_data() {
  metric_data_.Clear();
}
inline ::video_widevine::MetricData* SignedMessage::mutable_metric_data(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.metric_data)
  return metric_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >*
SignedMessage::mutable_metric_data() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.SignedMessage.metric_data)
  return &metric_data_;
}
inline const ::video_widevine::MetricData& SignedMessage::_internal_metric_data(int index) const {
  return metric_data_.Get(index);
}
inline const ::video_widevine::MetricData& SignedMessage::metric_data(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.metric_data)
  return _internal_metric_data(index);
}
inline ::video_widevine::MetricData* SignedMessage::_internal_add_metric_data() {
  return metric_data_.Add();
}
inline ::video_widevine::MetricData* SignedMessage::add_metric_data() {
  ::video_widevine::MetricData* _add = _internal_add_metric_data();
  // @@protoc_insertion_point(field_add:video_widevine.SignedMessage.metric_data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >&
SignedMessage::metric_data() const {
  // @@protoc_insertion_point(field_list:video_widevine.SignedMessage.metric_data)
  return metric_data_;
}

// optional .video_widevine.VersionInfo service_version_info = 7;
inline bool SignedMessage::_internal_has_service_version_info() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || service_version_info_ != nullptr);
  return value;
}
inline bool SignedMessage::has_service_version_info() const {
  return _internal_has_service_version_info();
}
inline void SignedMessage::clear_service_version_info() {
  if (service_version_info_ != nullptr) service_version_info_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
inline const ::video_widevine::VersionInfo& SignedMessage::_internal_service_version_info() const {
  const ::video_widevine::VersionInfo* p = service_version_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::VersionInfo&>(
      ::video_widevine::_VersionInfo_default_instance_);
}
inline const ::video_widevine::VersionInfo& SignedMessage::service_version_info() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.service_version_info)
  return _internal_service_version_info();
}
inline void SignedMessage::unsafe_arena_set_allocated_service_version_info(
    ::video_widevine::VersionInfo* service_version_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(service_version_info_);
  }
  service_version_info_ = service_version_info;
  if (service_version_info) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedMessage.service_version_info)
}
inline ::video_widevine::VersionInfo* SignedMessage::release_service_version_info() {
  _has_bits_[0] &= ~0x00000020u;
  ::video_widevine::VersionInfo* temp = service_version_info_;
  service_version_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::VersionInfo* SignedMessage::unsafe_arena_release_service_version_info() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.service_version_info)
  _has_bits_[0] &= ~0x00000020u;
  ::video_widevine::VersionInfo* temp = service_version_info_;
  service_version_info_ = nullptr;
  return temp;
}
inline ::video_widevine::VersionInfo* SignedMessage::_internal_mutable_service_version_info() {
  _has_bits_[0] |= 0x00000020u;
  if (service_version_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::VersionInfo>(GetArenaForAllocation());
    service_version_info_ = p;
  }
  return service_version_info_;
}
inline ::video_widevine::VersionInfo* SignedMessage::mutable_service_version_info() {
  ::video_widevine::VersionInfo* _msg = _internal_mutable_service_version_info();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.service_version_info)
  return _msg;
}
inline void SignedMessage::set_allocated_service_version_info(::video_widevine::VersionInfo* service_version_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete service_version_info_;
  }
  if (service_version_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::VersionInfo>::GetOwningArena(service_version_info);
    if (message_arena != submessage_arena) {
      service_version_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, service_version_info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  service_version_info_ = service_version_info;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.service_version_info)
}

// optional .video_widevine.SignedMessage.SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
inline bool SignedMessage::_internal_has_session_key_type() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SignedMessage::has_session_key_type() const {
  return _internal_has_session_key_type();
}
inline void SignedMessage::clear_session_key_type() {
  session_key_type_ = 1;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::video_widevine::SignedMessage_SessionKeyType SignedMessage::_internal_session_key_type() const {
  return static_cast< ::video_widevine::SignedMessage_SessionKeyType >(session_key_type_);
}
inline ::video_widevine::SignedMessage_SessionKeyType SignedMessage::session_key_type() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.session_key_type)
  return _internal_session_key_type();
}
inline void SignedMessage::_internal_set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value) {
  assert(::video_widevine::SignedMessage_SessionKeyType_IsValid(value));
  _has_bits_[0] |= 0x00000200u;
  session_key_type_ = value;
}
inline void SignedMessage::set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value) {
  _internal_set_session_key_type(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.session_key_type)
}

// optional bytes oemcrypto_core_message = 9;
inline bool SignedMessage::_internal_has_oemcrypto_core_message() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SignedMessage::has_oemcrypto_core_message() const {
  return _internal_has_oemcrypto_core_message();
}
inline void SignedMessage::clear_oemcrypto_core_message() {
  oemcrypto_core_message_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SignedMessage::oemcrypto_core_message() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.oemcrypto_core_message)
  return _internal_oemcrypto_core_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedMessage::set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 oemcrypto_core_message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.oemcrypto_core_message)
}
inline std::string* SignedMessage::mutable_oemcrypto_core_message() {
  std::string* _s = _internal_mutable_oemcrypto_core_message();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.oemcrypto_core_message)
  return _s;
}
inline const std::string& SignedMessage::_internal_oemcrypto_core_message() const {
  return oemcrypto_core_message_.Get();
}
inline void SignedMessage::_internal_set_oemcrypto_core_message(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  oemcrypto_core_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SignedMessage::_internal_mutable_oemcrypto_core_message() {
  _has_bits_[0] |= 0x00000008u;
  return oemcrypto_core_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SignedMessage::release_oemcrypto_core_message() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.oemcrypto_core_message)
  if (!_internal_has_oemcrypto_core_message()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return oemcrypto_core_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SignedMessage::set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message) {
  if (oemcrypto_core_message != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  oemcrypto_core_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oemcrypto_core_message,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.oemcrypto_core_message)
}

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

// optional bool using_secondary_key = 11;
inline bool SignedMessage::_internal_has_using_secondary_key() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SignedMessage::has_using_secondary_key() const {
  return _internal_has_using_secondary_key();
}
inline void SignedMessage::clear_using_secondary_key() {
  using_secondary_key_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool SignedMessage::_internal_using_secondary_key() const {
  return using_secondary_key_;
}
inline bool SignedMessage::using_secondary_key() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.using_secondary_key)
  return _internal_using_secondary_key();
}
inline void SignedMessage::_internal_set_using_secondary_key(bool value) {
  _has_bits_[0] |= 0x00000080u;
  using_secondary_key_ = value;
}
inline void SignedMessage::set_using_secondary_key(bool value) {
  _internal_set_using_secondary_key(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.using_secondary_key)
}

#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::LicenseCategorySpec_LicenseCategory> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseCategorySpec_LicenseCategory>() {
  return ::video_widevine::LicenseCategorySpec_LicenseCategory_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_Policy_WatermarkingControl> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_Policy_WatermarkingControl>() {
  return ::video_widevine::License_Policy_WatermarkingControl_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HDCP> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HDCP>() {
  return ::video_widevine::License_KeyContainer_OutputProtection_HDCP_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_CGMS> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_CGMS>() {
  return ::video_widevine::License_KeyContainer_OutputProtection_CGMS_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule>() {
  return ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory>() {
  return ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_KeyType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_KeyType>() {
  return ::video_widevine::License_KeyContainer_KeyType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_SecurityLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_SecurityLevel>() {
  return ::video_widevine::License_KeyContainer_SecurityLevel_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType>() {
  return ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::LicenseRequest_RequestType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseRequest_RequestType>() {
  return ::video_widevine::LicenseRequest_RequestType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::LicenseError_Error> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseError_Error>() {
  return ::video_widevine::LicenseError_Error_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::MetricData_MetricType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::MetricData_MetricType>() {
  return ::video_widevine::MetricData_MetricType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::SignedMessage_MessageType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedMessage_MessageType>() {
  return ::video_widevine::SignedMessage_MessageType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::SignedMessage_SessionKeyType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedMessage_SessionKeyType>() {
  return ::video_widevine::SignedMessage_SessionKeyType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::LicenseType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseType>() {
  return ::video_widevine::LicenseType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::PlatformVerificationStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlatformVerificationStatus>() {
  return ::video_widevine::PlatformVerificationStatus_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::ProtocolVersion> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProtocolVersion>() {
  return ::video_widevine::ProtocolVersion_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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