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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdtcp_5fusage_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdtcp_5fusage_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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdtcp_5fusage_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_2fdtcp_5fusage_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[1]
    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_2fdtcp_5fusage_2eproto;
namespace video_widevine {
class DTCPUsageRules;
struct DTCPUsageRulesDefaultTypeInternal;
extern DTCPUsageRulesDefaultTypeInternal _DTCPUsageRules_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::DTCPUsageRules* Arena::CreateMaybeMessage<::video_widevine::DTCPUsageRules>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum DTCPUsageRules_RetentionState : int {
  DTCPUsageRules_RetentionState_RETENTION_STATE_FOREVER = 0,
  DTCPUsageRules_RetentionState_RETENTION_STATE_1_WEEK = 1,
  DTCPUsageRules_RetentionState_RETENTION_STATE_2_DAYS = 2,
  DTCPUsageRules_RetentionState_RETENTION_STATE_1_DAY = 3,
  DTCPUsageRules_RetentionState_RETENTION_STATE_12_HOURS = 4,
  DTCPUsageRules_RetentionState_RETENTION_STATE_6_HOURS = 5,
  DTCPUsageRules_RetentionState_RETENTION_STATE_3_HOURS = 6,
  DTCPUsageRules_RetentionState_RETENTION_STATE_90_MINUTES = 7
};
bool DTCPUsageRules_RetentionState_IsValid(int value);
constexpr DTCPUsageRules_RetentionState DTCPUsageRules_RetentionState_RetentionState_MIN = DTCPUsageRules_RetentionState_RETENTION_STATE_FOREVER;
constexpr DTCPUsageRules_RetentionState DTCPUsageRules_RetentionState_RetentionState_MAX = DTCPUsageRules_RetentionState_RETENTION_STATE_90_MINUTES;
constexpr int DTCPUsageRules_RetentionState_RetentionState_ARRAYSIZE = DTCPUsageRules_RetentionState_RetentionState_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_RetentionState_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_RetentionState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_RetentionState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_RetentionState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_RetentionState_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_RetentionState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_RetentionState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_RetentionState>(
    DTCPUsageRules_RetentionState_descriptor(), name, value);
}
enum DTCPUsageRules_CopyControlInfo : int {
  DTCPUsageRules_CopyControlInfo_COPY_FREE = 0,
  DTCPUsageRules_CopyControlInfo_COPY_NO_MORE = 1,
  DTCPUsageRules_CopyControlInfo_COPY_ONE = 2,
  DTCPUsageRules_CopyControlInfo_COPY_NEVER = 3
};
bool DTCPUsageRules_CopyControlInfo_IsValid(int value);
constexpr DTCPUsageRules_CopyControlInfo DTCPUsageRules_CopyControlInfo_CopyControlInfo_MIN = DTCPUsageRules_CopyControlInfo_COPY_FREE;
constexpr DTCPUsageRules_CopyControlInfo DTCPUsageRules_CopyControlInfo_CopyControlInfo_MAX = DTCPUsageRules_CopyControlInfo_COPY_NEVER;
constexpr int DTCPUsageRules_CopyControlInfo_CopyControlInfo_ARRAYSIZE = DTCPUsageRules_CopyControlInfo_CopyControlInfo_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_CopyControlInfo_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_CopyControlInfo_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_CopyControlInfo>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_CopyControlInfo_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_CopyControlInfo_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_CopyControlInfo_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_CopyControlInfo* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_CopyControlInfo>(
    DTCPUsageRules_CopyControlInfo_descriptor(), name, value);
}
enum DTCPUsageRules_AnalogProtectionSystem : int {
  DTCPUsageRules_AnalogProtectionSystem_APS_OFF = 0,
  DTCPUsageRules_AnalogProtectionSystem_APS_TYPE1 = 1,
  DTCPUsageRules_AnalogProtectionSystem_APS_TYPE2 = 2,
  DTCPUsageRules_AnalogProtectionSystem_APS_TYPE3 = 3
};
bool DTCPUsageRules_AnalogProtectionSystem_IsValid(int value);
constexpr DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MIN = DTCPUsageRules_AnalogProtectionSystem_APS_OFF;
constexpr DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MAX = DTCPUsageRules_AnalogProtectionSystem_APS_TYPE3;
constexpr int DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_ARRAYSIZE = DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_AnalogProtectionSystem_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_AnalogProtectionSystem_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_AnalogProtectionSystem>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_AnalogProtectionSystem_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_AnalogProtectionSystem_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_AnalogProtectionSystem_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_AnalogProtectionSystem* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_AnalogProtectionSystem>(
    DTCPUsageRules_AnalogProtectionSystem_descriptor(), name, value);
}
enum DTCPUsageRules_ImageConstraintToken : int {
  DTCPUsageRules_ImageConstraintToken_ICT_CONSTRAINED = 0,
  DTCPUsageRules_ImageConstraintToken_ICT_HD_ANALOG = 1
};
bool DTCPUsageRules_ImageConstraintToken_IsValid(int value);
constexpr DTCPUsageRules_ImageConstraintToken DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MIN = DTCPUsageRules_ImageConstraintToken_ICT_CONSTRAINED;
constexpr DTCPUsageRules_ImageConstraintToken DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MAX = DTCPUsageRules_ImageConstraintToken_ICT_HD_ANALOG;
constexpr int DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_ARRAYSIZE = DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_ImageConstraintToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_ImageConstraintToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_ImageConstraintToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_ImageConstraintToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_ImageConstraintToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_ImageConstraintToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_ImageConstraintToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_ImageConstraintToken>(
    DTCPUsageRules_ImageConstraintToken_descriptor(), name, value);
}
enum DTCPUsageRules_AnalogSunsetToken : int {
  DTCPUsageRules_AnalogSunsetToken_AST_ASSERTED = 0,
  DTCPUsageRules_AnalogSunsetToken_AST_UNASERTED = 1
};
bool DTCPUsageRules_AnalogSunsetToken_IsValid(int value);
constexpr DTCPUsageRules_AnalogSunsetToken DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MIN = DTCPUsageRules_AnalogSunsetToken_AST_ASSERTED;
constexpr DTCPUsageRules_AnalogSunsetToken DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MAX = DTCPUsageRules_AnalogSunsetToken_AST_UNASERTED;
constexpr int DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_ARRAYSIZE = DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_AnalogSunsetToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_AnalogSunsetToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_AnalogSunsetToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_AnalogSunsetToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_AnalogSunsetToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_AnalogSunsetToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_AnalogSunsetToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_AnalogSunsetToken>(
    DTCPUsageRules_AnalogSunsetToken_descriptor(), name, value);
}
enum DTCPUsageRules_DigitalOnlyToken : int {
  DTCPUsageRules_DigitalOnlyToken_DOT_ASSERTED = 0,
  DTCPUsageRules_DigitalOnlyToken_DOT_UNASSERTED = 1
};
bool DTCPUsageRules_DigitalOnlyToken_IsValid(int value);
constexpr DTCPUsageRules_DigitalOnlyToken DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MIN = DTCPUsageRules_DigitalOnlyToken_DOT_ASSERTED;
constexpr DTCPUsageRules_DigitalOnlyToken DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MAX = DTCPUsageRules_DigitalOnlyToken_DOT_UNASSERTED;
constexpr int DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_ARRAYSIZE = DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_DigitalOnlyToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_DigitalOnlyToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_DigitalOnlyToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_DigitalOnlyToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_DigitalOnlyToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_DigitalOnlyToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_DigitalOnlyToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_DigitalOnlyToken>(
    DTCPUsageRules_DigitalOnlyToken_descriptor(), name, value);
}
enum DTCPUsageRules_AudioEnhancedToken : int {
  DTCPUsageRules_AudioEnhancedToken_AET_ASSERTED = 0,
  DTCPUsageRules_AudioEnhancedToken_AET_UNASSERTED = 1
};
bool DTCPUsageRules_AudioEnhancedToken_IsValid(int value);
constexpr DTCPUsageRules_AudioEnhancedToken DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MIN = DTCPUsageRules_AudioEnhancedToken_AET_ASSERTED;
constexpr DTCPUsageRules_AudioEnhancedToken DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MAX = DTCPUsageRules_AudioEnhancedToken_AET_UNASSERTED;
constexpr int DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_ARRAYSIZE = DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_AudioEnhancedToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_AudioEnhancedToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_AudioEnhancedToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_AudioEnhancedToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_AudioEnhancedToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_AudioEnhancedToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_AudioEnhancedToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_AudioEnhancedToken>(
    DTCPUsageRules_AudioEnhancedToken_descriptor(), name, value);
}
enum DTCPUsageRules_StandardDigitalOutputToken : int {
  DTCPUsageRules_StandardDigitalOutputToken_SDO_UNASSEERTED = 0,
  DTCPUsageRules_StandardDigitalOutputToken_SDO_ASSEERTED = 1
};
bool DTCPUsageRules_StandardDigitalOutputToken_IsValid(int value);
constexpr DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MIN = DTCPUsageRules_StandardDigitalOutputToken_SDO_UNASSEERTED;
constexpr DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MAX = DTCPUsageRules_StandardDigitalOutputToken_SDO_ASSEERTED;
constexpr int DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_ARRAYSIZE = DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_StandardDigitalOutputToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_StandardDigitalOutputToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_StandardDigitalOutputToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_StandardDigitalOutputToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_StandardDigitalOutputToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_StandardDigitalOutputToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_StandardDigitalOutputToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_StandardDigitalOutputToken>(
    DTCPUsageRules_StandardDigitalOutputToken_descriptor(), name, value);
}
enum DTCPUsageRules_HighDynamicRangeToken : int {
  DTCPUsageRules_HighDynamicRangeToken_HDR_UNASSERTED = 0,
  DTCPUsageRules_HighDynamicRangeToken_HDR_ASSERTED = 1
};
bool DTCPUsageRules_HighDynamicRangeToken_IsValid(int value);
constexpr DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MIN = DTCPUsageRules_HighDynamicRangeToken_HDR_UNASSERTED;
constexpr DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MAX = DTCPUsageRules_HighDynamicRangeToken_HDR_ASSERTED;
constexpr int DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_ARRAYSIZE = DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_HighDynamicRangeToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_HighDynamicRangeToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_HighDynamicRangeToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_HighDynamicRangeToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_HighDynamicRangeToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_HighDynamicRangeToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_HighDynamicRangeToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_HighDynamicRangeToken>(
    DTCPUsageRules_HighDynamicRangeToken_descriptor(), name, value);
}
enum DTCPUsageRules_L2ProtectionOnlyToken : int {
  DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_UNASSERTED = 0,
  DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_ASSERTED = 1
};
bool DTCPUsageRules_L2ProtectionOnlyToken_IsValid(int value);
constexpr DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MIN = DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_UNASSERTED;
constexpr DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MAX = DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_ASSERTED;
constexpr int DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_ARRAYSIZE = DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_L2ProtectionOnlyToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_L2ProtectionOnlyToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_L2ProtectionOnlyToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_L2ProtectionOnlyToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_L2ProtectionOnlyToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_L2ProtectionOnlyToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_L2ProtectionOnlyToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_L2ProtectionOnlyToken>(
    DTCPUsageRules_L2ProtectionOnlyToken_descriptor(), name, value);
}
enum DTCPUsageRules_EnhancedImageToken : int {
  DTCPUsageRules_EnhancedImageToken_EI_UNASSERTED = 0,
  DTCPUsageRules_EnhancedImageToken_EI_ASSERTED = 1
};
bool DTCPUsageRules_EnhancedImageToken_IsValid(int value);
constexpr DTCPUsageRules_EnhancedImageToken DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MIN = DTCPUsageRules_EnhancedImageToken_EI_UNASSERTED;
constexpr DTCPUsageRules_EnhancedImageToken DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MAX = DTCPUsageRules_EnhancedImageToken_EI_ASSERTED;
constexpr int DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_ARRAYSIZE = DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DTCPUsageRules_EnhancedImageToken_descriptor();
template<typename T>
inline const std::string& DTCPUsageRules_EnhancedImageToken_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DTCPUsageRules_EnhancedImageToken>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DTCPUsageRules_EnhancedImageToken_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DTCPUsageRules_EnhancedImageToken_descriptor(), enum_t_value);
}
inline bool DTCPUsageRules_EnhancedImageToken_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DTCPUsageRules_EnhancedImageToken* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DTCPUsageRules_EnhancedImageToken>(
    DTCPUsageRules_EnhancedImageToken_descriptor(), name, value);
}
enum DTCPUsageRules_FurtherBoundCopy : int {
  DTCPUsageRules_FurtherBoundCopy_FBC_PROHIBITED = 0,
  DTCPUsageRules_FurtherBoundCopy_FBC_PERMITTED = 1
};
bool DTCPUsageRules_FurtherBoundCopy_IsValid(int value);
constexpr DTCPUsageRules_FurtherBoundCopy DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MIN = DTCPUsageRules_FurtherBoundCopy_FBC_PROHIBITED;
constexpr DTCPUsageRules_FurtherBoundCopy DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MAX = DTCPUsageRules_FurtherBoundCopy_FBC_PERMITTED;
constexpr int DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_ARRAYSIZE = DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MAX + 1;

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

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

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

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

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

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

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

  DTCPUsageRules* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DTCPUsageRules>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DTCPUsageRules& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DTCPUsageRules& 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(DTCPUsageRules* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DTCPUsageRules";
  }
  protected:
  explicit DTCPUsageRules(::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 DTCPUsageRules_RetentionState RetentionState;
  static constexpr RetentionState RETENTION_STATE_FOREVER =
    DTCPUsageRules_RetentionState_RETENTION_STATE_FOREVER;
  static constexpr RetentionState RETENTION_STATE_1_WEEK =
    DTCPUsageRules_RetentionState_RETENTION_STATE_1_WEEK;
  static constexpr RetentionState RETENTION_STATE_2_DAYS =
    DTCPUsageRules_RetentionState_RETENTION_STATE_2_DAYS;
  static constexpr RetentionState RETENTION_STATE_1_DAY =
    DTCPUsageRules_RetentionState_RETENTION_STATE_1_DAY;
  static constexpr RetentionState RETENTION_STATE_12_HOURS =
    DTCPUsageRules_RetentionState_RETENTION_STATE_12_HOURS;
  static constexpr RetentionState RETENTION_STATE_6_HOURS =
    DTCPUsageRules_RetentionState_RETENTION_STATE_6_HOURS;
  static constexpr RetentionState RETENTION_STATE_3_HOURS =
    DTCPUsageRules_RetentionState_RETENTION_STATE_3_HOURS;
  static constexpr RetentionState RETENTION_STATE_90_MINUTES =
    DTCPUsageRules_RetentionState_RETENTION_STATE_90_MINUTES;
  static inline bool RetentionState_IsValid(int value) {
    return DTCPUsageRules_RetentionState_IsValid(value);
  }
  static constexpr RetentionState RetentionState_MIN =
    DTCPUsageRules_RetentionState_RetentionState_MIN;
  static constexpr RetentionState RetentionState_MAX =
    DTCPUsageRules_RetentionState_RetentionState_MAX;
  static constexpr int RetentionState_ARRAYSIZE =
    DTCPUsageRules_RetentionState_RetentionState_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RetentionState_descriptor() {
    return DTCPUsageRules_RetentionState_descriptor();
  }
  template<typename T>
  static inline const std::string& RetentionState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RetentionState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RetentionState_Name.");
    return DTCPUsageRules_RetentionState_Name(enum_t_value);
  }
  static inline bool RetentionState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RetentionState* value) {
    return DTCPUsageRules_RetentionState_Parse(name, value);
  }

  typedef DTCPUsageRules_CopyControlInfo CopyControlInfo;
  static constexpr CopyControlInfo COPY_FREE =
    DTCPUsageRules_CopyControlInfo_COPY_FREE;
  static constexpr CopyControlInfo COPY_NO_MORE =
    DTCPUsageRules_CopyControlInfo_COPY_NO_MORE;
  static constexpr CopyControlInfo COPY_ONE =
    DTCPUsageRules_CopyControlInfo_COPY_ONE;
  static constexpr CopyControlInfo COPY_NEVER =
    DTCPUsageRules_CopyControlInfo_COPY_NEVER;
  static inline bool CopyControlInfo_IsValid(int value) {
    return DTCPUsageRules_CopyControlInfo_IsValid(value);
  }
  static constexpr CopyControlInfo CopyControlInfo_MIN =
    DTCPUsageRules_CopyControlInfo_CopyControlInfo_MIN;
  static constexpr CopyControlInfo CopyControlInfo_MAX =
    DTCPUsageRules_CopyControlInfo_CopyControlInfo_MAX;
  static constexpr int CopyControlInfo_ARRAYSIZE =
    DTCPUsageRules_CopyControlInfo_CopyControlInfo_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  CopyControlInfo_descriptor() {
    return DTCPUsageRules_CopyControlInfo_descriptor();
  }
  template<typename T>
  static inline const std::string& CopyControlInfo_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CopyControlInfo>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CopyControlInfo_Name.");
    return DTCPUsageRules_CopyControlInfo_Name(enum_t_value);
  }
  static inline bool CopyControlInfo_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CopyControlInfo* value) {
    return DTCPUsageRules_CopyControlInfo_Parse(name, value);
  }

  typedef DTCPUsageRules_AnalogProtectionSystem AnalogProtectionSystem;
  static constexpr AnalogProtectionSystem APS_OFF =
    DTCPUsageRules_AnalogProtectionSystem_APS_OFF;
  static constexpr AnalogProtectionSystem APS_TYPE1 =
    DTCPUsageRules_AnalogProtectionSystem_APS_TYPE1;
  static constexpr AnalogProtectionSystem APS_TYPE2 =
    DTCPUsageRules_AnalogProtectionSystem_APS_TYPE2;
  static constexpr AnalogProtectionSystem APS_TYPE3 =
    DTCPUsageRules_AnalogProtectionSystem_APS_TYPE3;
  static inline bool AnalogProtectionSystem_IsValid(int value) {
    return DTCPUsageRules_AnalogProtectionSystem_IsValid(value);
  }
  static constexpr AnalogProtectionSystem AnalogProtectionSystem_MIN =
    DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MIN;
  static constexpr AnalogProtectionSystem AnalogProtectionSystem_MAX =
    DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_MAX;
  static constexpr int AnalogProtectionSystem_ARRAYSIZE =
    DTCPUsageRules_AnalogProtectionSystem_AnalogProtectionSystem_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  AnalogProtectionSystem_descriptor() {
    return DTCPUsageRules_AnalogProtectionSystem_descriptor();
  }
  template<typename T>
  static inline const std::string& AnalogProtectionSystem_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AnalogProtectionSystem>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AnalogProtectionSystem_Name.");
    return DTCPUsageRules_AnalogProtectionSystem_Name(enum_t_value);
  }
  static inline bool AnalogProtectionSystem_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AnalogProtectionSystem* value) {
    return DTCPUsageRules_AnalogProtectionSystem_Parse(name, value);
  }

  typedef DTCPUsageRules_ImageConstraintToken ImageConstraintToken;
  static constexpr ImageConstraintToken ICT_CONSTRAINED =
    DTCPUsageRules_ImageConstraintToken_ICT_CONSTRAINED;
  static constexpr ImageConstraintToken ICT_HD_ANALOG =
    DTCPUsageRules_ImageConstraintToken_ICT_HD_ANALOG;
  static inline bool ImageConstraintToken_IsValid(int value) {
    return DTCPUsageRules_ImageConstraintToken_IsValid(value);
  }
  static constexpr ImageConstraintToken ImageConstraintToken_MIN =
    DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MIN;
  static constexpr ImageConstraintToken ImageConstraintToken_MAX =
    DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_MAX;
  static constexpr int ImageConstraintToken_ARRAYSIZE =
    DTCPUsageRules_ImageConstraintToken_ImageConstraintToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ImageConstraintToken_descriptor() {
    return DTCPUsageRules_ImageConstraintToken_descriptor();
  }
  template<typename T>
  static inline const std::string& ImageConstraintToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ImageConstraintToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ImageConstraintToken_Name.");
    return DTCPUsageRules_ImageConstraintToken_Name(enum_t_value);
  }
  static inline bool ImageConstraintToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ImageConstraintToken* value) {
    return DTCPUsageRules_ImageConstraintToken_Parse(name, value);
  }

  typedef DTCPUsageRules_AnalogSunsetToken AnalogSunsetToken;
  static constexpr AnalogSunsetToken AST_ASSERTED =
    DTCPUsageRules_AnalogSunsetToken_AST_ASSERTED;
  static constexpr AnalogSunsetToken AST_UNASERTED =
    DTCPUsageRules_AnalogSunsetToken_AST_UNASERTED;
  static inline bool AnalogSunsetToken_IsValid(int value) {
    return DTCPUsageRules_AnalogSunsetToken_IsValid(value);
  }
  static constexpr AnalogSunsetToken AnalogSunsetToken_MIN =
    DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MIN;
  static constexpr AnalogSunsetToken AnalogSunsetToken_MAX =
    DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_MAX;
  static constexpr int AnalogSunsetToken_ARRAYSIZE =
    DTCPUsageRules_AnalogSunsetToken_AnalogSunsetToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  AnalogSunsetToken_descriptor() {
    return DTCPUsageRules_AnalogSunsetToken_descriptor();
  }
  template<typename T>
  static inline const std::string& AnalogSunsetToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AnalogSunsetToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AnalogSunsetToken_Name.");
    return DTCPUsageRules_AnalogSunsetToken_Name(enum_t_value);
  }
  static inline bool AnalogSunsetToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AnalogSunsetToken* value) {
    return DTCPUsageRules_AnalogSunsetToken_Parse(name, value);
  }

  typedef DTCPUsageRules_DigitalOnlyToken DigitalOnlyToken;
  static constexpr DigitalOnlyToken DOT_ASSERTED =
    DTCPUsageRules_DigitalOnlyToken_DOT_ASSERTED;
  static constexpr DigitalOnlyToken DOT_UNASSERTED =
    DTCPUsageRules_DigitalOnlyToken_DOT_UNASSERTED;
  static inline bool DigitalOnlyToken_IsValid(int value) {
    return DTCPUsageRules_DigitalOnlyToken_IsValid(value);
  }
  static constexpr DigitalOnlyToken DigitalOnlyToken_MIN =
    DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MIN;
  static constexpr DigitalOnlyToken DigitalOnlyToken_MAX =
    DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_MAX;
  static constexpr int DigitalOnlyToken_ARRAYSIZE =
    DTCPUsageRules_DigitalOnlyToken_DigitalOnlyToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DigitalOnlyToken_descriptor() {
    return DTCPUsageRules_DigitalOnlyToken_descriptor();
  }
  template<typename T>
  static inline const std::string& DigitalOnlyToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DigitalOnlyToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DigitalOnlyToken_Name.");
    return DTCPUsageRules_DigitalOnlyToken_Name(enum_t_value);
  }
  static inline bool DigitalOnlyToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DigitalOnlyToken* value) {
    return DTCPUsageRules_DigitalOnlyToken_Parse(name, value);
  }

  typedef DTCPUsageRules_AudioEnhancedToken AudioEnhancedToken;
  static constexpr AudioEnhancedToken AET_ASSERTED =
    DTCPUsageRules_AudioEnhancedToken_AET_ASSERTED;
  static constexpr AudioEnhancedToken AET_UNASSERTED =
    DTCPUsageRules_AudioEnhancedToken_AET_UNASSERTED;
  static inline bool AudioEnhancedToken_IsValid(int value) {
    return DTCPUsageRules_AudioEnhancedToken_IsValid(value);
  }
  static constexpr AudioEnhancedToken AudioEnhancedToken_MIN =
    DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MIN;
  static constexpr AudioEnhancedToken AudioEnhancedToken_MAX =
    DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_MAX;
  static constexpr int AudioEnhancedToken_ARRAYSIZE =
    DTCPUsageRules_AudioEnhancedToken_AudioEnhancedToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  AudioEnhancedToken_descriptor() {
    return DTCPUsageRules_AudioEnhancedToken_descriptor();
  }
  template<typename T>
  static inline const std::string& AudioEnhancedToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AudioEnhancedToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AudioEnhancedToken_Name.");
    return DTCPUsageRules_AudioEnhancedToken_Name(enum_t_value);
  }
  static inline bool AudioEnhancedToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AudioEnhancedToken* value) {
    return DTCPUsageRules_AudioEnhancedToken_Parse(name, value);
  }

  typedef DTCPUsageRules_StandardDigitalOutputToken StandardDigitalOutputToken;
  static constexpr StandardDigitalOutputToken SDO_UNASSEERTED =
    DTCPUsageRules_StandardDigitalOutputToken_SDO_UNASSEERTED;
  static constexpr StandardDigitalOutputToken SDO_ASSEERTED =
    DTCPUsageRules_StandardDigitalOutputToken_SDO_ASSEERTED;
  static inline bool StandardDigitalOutputToken_IsValid(int value) {
    return DTCPUsageRules_StandardDigitalOutputToken_IsValid(value);
  }
  static constexpr StandardDigitalOutputToken StandardDigitalOutputToken_MIN =
    DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MIN;
  static constexpr StandardDigitalOutputToken StandardDigitalOutputToken_MAX =
    DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_MAX;
  static constexpr int StandardDigitalOutputToken_ARRAYSIZE =
    DTCPUsageRules_StandardDigitalOutputToken_StandardDigitalOutputToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  StandardDigitalOutputToken_descriptor() {
    return DTCPUsageRules_StandardDigitalOutputToken_descriptor();
  }
  template<typename T>
  static inline const std::string& StandardDigitalOutputToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, StandardDigitalOutputToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function StandardDigitalOutputToken_Name.");
    return DTCPUsageRules_StandardDigitalOutputToken_Name(enum_t_value);
  }
  static inline bool StandardDigitalOutputToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      StandardDigitalOutputToken* value) {
    return DTCPUsageRules_StandardDigitalOutputToken_Parse(name, value);
  }

  typedef DTCPUsageRules_HighDynamicRangeToken HighDynamicRangeToken;
  static constexpr HighDynamicRangeToken HDR_UNASSERTED =
    DTCPUsageRules_HighDynamicRangeToken_HDR_UNASSERTED;
  static constexpr HighDynamicRangeToken HDR_ASSERTED =
    DTCPUsageRules_HighDynamicRangeToken_HDR_ASSERTED;
  static inline bool HighDynamicRangeToken_IsValid(int value) {
    return DTCPUsageRules_HighDynamicRangeToken_IsValid(value);
  }
  static constexpr HighDynamicRangeToken HighDynamicRangeToken_MIN =
    DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MIN;
  static constexpr HighDynamicRangeToken HighDynamicRangeToken_MAX =
    DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_MAX;
  static constexpr int HighDynamicRangeToken_ARRAYSIZE =
    DTCPUsageRules_HighDynamicRangeToken_HighDynamicRangeToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HighDynamicRangeToken_descriptor() {
    return DTCPUsageRules_HighDynamicRangeToken_descriptor();
  }
  template<typename T>
  static inline const std::string& HighDynamicRangeToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HighDynamicRangeToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HighDynamicRangeToken_Name.");
    return DTCPUsageRules_HighDynamicRangeToken_Name(enum_t_value);
  }
  static inline bool HighDynamicRangeToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HighDynamicRangeToken* value) {
    return DTCPUsageRules_HighDynamicRangeToken_Parse(name, value);
  }

  typedef DTCPUsageRules_L2ProtectionOnlyToken L2ProtectionOnlyToken;
  static constexpr L2ProtectionOnlyToken L2_ONLY_UNASSERTED =
    DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_UNASSERTED;
  static constexpr L2ProtectionOnlyToken L2_ONLY_ASSERTED =
    DTCPUsageRules_L2ProtectionOnlyToken_L2_ONLY_ASSERTED;
  static inline bool L2ProtectionOnlyToken_IsValid(int value) {
    return DTCPUsageRules_L2ProtectionOnlyToken_IsValid(value);
  }
  static constexpr L2ProtectionOnlyToken L2ProtectionOnlyToken_MIN =
    DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MIN;
  static constexpr L2ProtectionOnlyToken L2ProtectionOnlyToken_MAX =
    DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_MAX;
  static constexpr int L2ProtectionOnlyToken_ARRAYSIZE =
    DTCPUsageRules_L2ProtectionOnlyToken_L2ProtectionOnlyToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  L2ProtectionOnlyToken_descriptor() {
    return DTCPUsageRules_L2ProtectionOnlyToken_descriptor();
  }
  template<typename T>
  static inline const std::string& L2ProtectionOnlyToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, L2ProtectionOnlyToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function L2ProtectionOnlyToken_Name.");
    return DTCPUsageRules_L2ProtectionOnlyToken_Name(enum_t_value);
  }
  static inline bool L2ProtectionOnlyToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      L2ProtectionOnlyToken* value) {
    return DTCPUsageRules_L2ProtectionOnlyToken_Parse(name, value);
  }

  typedef DTCPUsageRules_EnhancedImageToken EnhancedImageToken;
  static constexpr EnhancedImageToken EI_UNASSERTED =
    DTCPUsageRules_EnhancedImageToken_EI_UNASSERTED;
  static constexpr EnhancedImageToken EI_ASSERTED =
    DTCPUsageRules_EnhancedImageToken_EI_ASSERTED;
  static inline bool EnhancedImageToken_IsValid(int value) {
    return DTCPUsageRules_EnhancedImageToken_IsValid(value);
  }
  static constexpr EnhancedImageToken EnhancedImageToken_MIN =
    DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MIN;
  static constexpr EnhancedImageToken EnhancedImageToken_MAX =
    DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_MAX;
  static constexpr int EnhancedImageToken_ARRAYSIZE =
    DTCPUsageRules_EnhancedImageToken_EnhancedImageToken_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  EnhancedImageToken_descriptor() {
    return DTCPUsageRules_EnhancedImageToken_descriptor();
  }
  template<typename T>
  static inline const std::string& EnhancedImageToken_Name(T enum_t_value) {
    static_assert(::std::is_same<T, EnhancedImageToken>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function EnhancedImageToken_Name.");
    return DTCPUsageRules_EnhancedImageToken_Name(enum_t_value);
  }
  static inline bool EnhancedImageToken_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      EnhancedImageToken* value) {
    return DTCPUsageRules_EnhancedImageToken_Parse(name, value);
  }

  typedef DTCPUsageRules_FurtherBoundCopy FurtherBoundCopy;
  static constexpr FurtherBoundCopy FBC_PROHIBITED =
    DTCPUsageRules_FurtherBoundCopy_FBC_PROHIBITED;
  static constexpr FurtherBoundCopy FBC_PERMITTED =
    DTCPUsageRules_FurtherBoundCopy_FBC_PERMITTED;
  static inline bool FurtherBoundCopy_IsValid(int value) {
    return DTCPUsageRules_FurtherBoundCopy_IsValid(value);
  }
  static constexpr FurtherBoundCopy FurtherBoundCopy_MIN =
    DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MIN;
  static constexpr FurtherBoundCopy FurtherBoundCopy_MAX =
    DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_MAX;
  static constexpr int FurtherBoundCopy_ARRAYSIZE =
    DTCPUsageRules_FurtherBoundCopy_FurtherBoundCopy_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  FurtherBoundCopy_descriptor() {
    return DTCPUsageRules_FurtherBoundCopy_descriptor();
  }
  template<typename T>
  static inline const std::string& FurtherBoundCopy_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FurtherBoundCopy>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FurtherBoundCopy_Name.");
    return DTCPUsageRules_FurtherBoundCopy_Name(enum_t_value);
  }
  static inline bool FurtherBoundCopy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      FurtherBoundCopy* value) {
    return DTCPUsageRules_FurtherBoundCopy_Parse(name, value);
  }

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

  enum : int {
    kCopyControlFieldNumber = 2,
    kRequireDtcp2FieldNumber = 1,
    kEncryptionPlusFieldNumber = 3,
    kRetentionStateFieldNumber = 4,
    kAnalogProtectionSystemFieldNumber = 5,
    kImageConstraintTokenFieldNumber = 6,
    kAnalogSunsetTokenFieldNumber = 7,
    kDigitalOnlyTokenFieldNumber = 8,
    kAudioEnhancedTokenFieldNumber = 9,
    kCopyCountFieldNumber = 10,
    kStandardDigitalTokenFieldNumber = 11,
    kHighDynamicTokenFieldNumber = 12,
    kL2OnlyTokenFieldNumber = 13,
    kEnhanedImageTokenFieldNumber = 14,
    kRetentionTimeFieldNumber = 15,
    kFurtherCopyFieldNumber = 16,
  };
  // optional .video_widevine.DTCPUsageRules.CopyControlInfo copy_control = 2;
  bool has_copy_control() const;
  private:
  bool _internal_has_copy_control() const;
  public:
  void clear_copy_control();
  ::video_widevine::DTCPUsageRules_CopyControlInfo copy_control() const;
  void set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value);
  private:
  ::video_widevine::DTCPUsageRules_CopyControlInfo _internal_copy_control() const;
  void _internal_set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value);
  public:

  // optional bool require_dtcp2 = 1 [default = false];
  bool has_require_dtcp2() const;
  private:
  bool _internal_has_require_dtcp2() const;
  public:
  void clear_require_dtcp2();
  bool require_dtcp2() const;
  void set_require_dtcp2(bool value);
  private:
  bool _internal_require_dtcp2() const;
  void _internal_set_require_dtcp2(bool value);
  public:

  // optional bool encryption_plus = 3;
  bool has_encryption_plus() const;
  private:
  bool _internal_has_encryption_plus() const;
  public:
  void clear_encryption_plus();
  bool encryption_plus() const;
  void set_encryption_plus(bool value);
  private:
  bool _internal_encryption_plus() const;
  void _internal_set_encryption_plus(bool value);
  public:

  // optional .video_widevine.DTCPUsageRules.RetentionState retention_state = 4;
  bool has_retention_state() const;
  private:
  bool _internal_has_retention_state() const;
  public:
  void clear_retention_state();
  ::video_widevine::DTCPUsageRules_RetentionState retention_state() const;
  void set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value);
  private:
  ::video_widevine::DTCPUsageRules_RetentionState _internal_retention_state() const;
  void _internal_set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value);
  public:

  // optional .video_widevine.DTCPUsageRules.AnalogProtectionSystem analog_protection_system = 5;
  bool has_analog_protection_system() const;
  private:
  bool _internal_has_analog_protection_system() const;
  public:
  void clear_analog_protection_system();
  ::video_widevine::DTCPUsageRules_AnalogProtectionSystem analog_protection_system() const;
  void set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value);
  private:
  ::video_widevine::DTCPUsageRules_AnalogProtectionSystem _internal_analog_protection_system() const;
  void _internal_set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value);
  public:

  // optional .video_widevine.DTCPUsageRules.ImageConstraintToken image_constraint_token = 6;
  bool has_image_constraint_token() const;
  private:
  bool _internal_has_image_constraint_token() const;
  public:
  void clear_image_constraint_token();
  ::video_widevine::DTCPUsageRules_ImageConstraintToken image_constraint_token() const;
  void set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value);
  private:
  ::video_widevine::DTCPUsageRules_ImageConstraintToken _internal_image_constraint_token() const;
  void _internal_set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value);
  public:

  // optional .video_widevine.DTCPUsageRules.AnalogSunsetToken analog_sunset_token = 7;
  bool has_analog_sunset_token() const;
  private:
  bool _internal_has_analog_sunset_token() const;
  public:
  void clear_analog_sunset_token();
  ::video_widevine::DTCPUsageRules_AnalogSunsetToken analog_sunset_token() const;
  void set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value);
  private:
  ::video_widevine::DTCPUsageRules_AnalogSunsetToken _internal_analog_sunset_token() const;
  void _internal_set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value);
  public:

  // optional .video_widevine.DTCPUsageRules.DigitalOnlyToken digital_only_token = 8;
  bool has_digital_only_token() const;
  private:
  bool _internal_has_digital_only_token() const;
  public:
  void clear_digital_only_token();
  ::video_widevine::DTCPUsageRules_DigitalOnlyToken digital_only_token() const;
  void set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value);
  private:
  ::video_widevine::DTCPUsageRules_DigitalOnlyToken _internal_digital_only_token() const;
  void _internal_set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value);
  public:

  // optional .video_widevine.DTCPUsageRules.AudioEnhancedToken audio_enhanced_token = 9;
  bool has_audio_enhanced_token() const;
  private:
  bool _internal_has_audio_enhanced_token() const;
  public:
  void clear_audio_enhanced_token();
  ::video_widevine::DTCPUsageRules_AudioEnhancedToken audio_enhanced_token() const;
  void set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value);
  private:
  ::video_widevine::DTCPUsageRules_AudioEnhancedToken _internal_audio_enhanced_token() const;
  void _internal_set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value);
  public:

  // optional uint32 copy_count = 10;
  bool has_copy_count() const;
  private:
  bool _internal_has_copy_count() const;
  public:
  void clear_copy_count();
  ::PROTOBUF_NAMESPACE_ID::uint32 copy_count() const;
  void set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_copy_count() const;
  void _internal_set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.DTCPUsageRules.StandardDigitalOutputToken standard_digital_token = 11;
  bool has_standard_digital_token() const;
  private:
  bool _internal_has_standard_digital_token() const;
  public:
  void clear_standard_digital_token();
  ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken standard_digital_token() const;
  void set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value);
  private:
  ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken _internal_standard_digital_token() const;
  void _internal_set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value);
  public:

  // optional .video_widevine.DTCPUsageRules.HighDynamicRangeToken high_dynamic_token = 12;
  bool has_high_dynamic_token() const;
  private:
  bool _internal_has_high_dynamic_token() const;
  public:
  void clear_high_dynamic_token();
  ::video_widevine::DTCPUsageRules_HighDynamicRangeToken high_dynamic_token() const;
  void set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value);
  private:
  ::video_widevine::DTCPUsageRules_HighDynamicRangeToken _internal_high_dynamic_token() const;
  void _internal_set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value);
  public:

  // optional .video_widevine.DTCPUsageRules.L2ProtectionOnlyToken l2_only_token = 13;
  bool has_l2_only_token() const;
  private:
  bool _internal_has_l2_only_token() const;
  public:
  void clear_l2_only_token();
  ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken l2_only_token() const;
  void set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value);
  private:
  ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken _internal_l2_only_token() const;
  void _internal_set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value);
  public:

  // optional .video_widevine.DTCPUsageRules.EnhancedImageToken enhaned_image_token = 14;
  bool has_enhaned_image_token() const;
  private:
  bool _internal_has_enhaned_image_token() const;
  public:
  void clear_enhaned_image_token();
  ::video_widevine::DTCPUsageRules_EnhancedImageToken enhaned_image_token() const;
  void set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value);
  private:
  ::video_widevine::DTCPUsageRules_EnhancedImageToken _internal_enhaned_image_token() const;
  void _internal_set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value);
  public:

  // optional uint32 retention_time = 15;
  bool has_retention_time() const;
  private:
  bool _internal_has_retention_time() const;
  public:
  void clear_retention_time();
  ::PROTOBUF_NAMESPACE_ID::uint32 retention_time() const;
  void set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_retention_time() const;
  void _internal_set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.DTCPUsageRules.FurtherBoundCopy further_copy = 16;
  bool has_further_copy() const;
  private:
  bool _internal_has_further_copy() const;
  public:
  void clear_further_copy();
  ::video_widevine::DTCPUsageRules_FurtherBoundCopy further_copy() const;
  void set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value);
  private:
  ::video_widevine::DTCPUsageRules_FurtherBoundCopy _internal_further_copy() const;
  void _internal_set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DTCPUsageRules)
 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 copy_control_;
  bool require_dtcp2_;
  bool encryption_plus_;
  int retention_state_;
  int analog_protection_system_;
  int image_constraint_token_;
  int analog_sunset_token_;
  int digital_only_token_;
  int audio_enhanced_token_;
  ::PROTOBUF_NAMESPACE_ID::uint32 copy_count_;
  int standard_digital_token_;
  int high_dynamic_token_;
  int l2_only_token_;
  int enhaned_image_token_;
  ::PROTOBUF_NAMESPACE_ID::uint32 retention_time_;
  int further_copy_;
  friend struct ::TableStruct_protos_2fpublic_2fdtcp_5fusage_2eproto;
};
// ===================================================================


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

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

// optional bool require_dtcp2 = 1 [default = false];
inline bool DTCPUsageRules::_internal_has_require_dtcp2() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_require_dtcp2() const {
  return _internal_has_require_dtcp2();
}
inline void DTCPUsageRules::clear_require_dtcp2() {
  require_dtcp2_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool DTCPUsageRules::_internal_require_dtcp2() const {
  return require_dtcp2_;
}
inline bool DTCPUsageRules::require_dtcp2() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.require_dtcp2)
  return _internal_require_dtcp2();
}
inline void DTCPUsageRules::_internal_set_require_dtcp2(bool value) {
  _has_bits_[0] |= 0x00000002u;
  require_dtcp2_ = value;
}
inline void DTCPUsageRules::set_require_dtcp2(bool value) {
  _internal_set_require_dtcp2(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.require_dtcp2)
}

// optional .video_widevine.DTCPUsageRules.CopyControlInfo copy_control = 2;
inline bool DTCPUsageRules::_internal_has_copy_control() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_copy_control() const {
  return _internal_has_copy_control();
}
inline void DTCPUsageRules::clear_copy_control() {
  copy_control_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::video_widevine::DTCPUsageRules_CopyControlInfo DTCPUsageRules::_internal_copy_control() const {
  return static_cast< ::video_widevine::DTCPUsageRules_CopyControlInfo >(copy_control_);
}
inline ::video_widevine::DTCPUsageRules_CopyControlInfo DTCPUsageRules::copy_control() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.copy_control)
  return _internal_copy_control();
}
inline void DTCPUsageRules::_internal_set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value) {
  assert(::video_widevine::DTCPUsageRules_CopyControlInfo_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  copy_control_ = value;
}
inline void DTCPUsageRules::set_copy_control(::video_widevine::DTCPUsageRules_CopyControlInfo value) {
  _internal_set_copy_control(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.copy_control)
}

// optional bool encryption_plus = 3;
inline bool DTCPUsageRules::_internal_has_encryption_plus() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_encryption_plus() const {
  return _internal_has_encryption_plus();
}
inline void DTCPUsageRules::clear_encryption_plus() {
  encryption_plus_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool DTCPUsageRules::_internal_encryption_plus() const {
  return encryption_plus_;
}
inline bool DTCPUsageRules::encryption_plus() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.encryption_plus)
  return _internal_encryption_plus();
}
inline void DTCPUsageRules::_internal_set_encryption_plus(bool value) {
  _has_bits_[0] |= 0x00000004u;
  encryption_plus_ = value;
}
inline void DTCPUsageRules::set_encryption_plus(bool value) {
  _internal_set_encryption_plus(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.encryption_plus)
}

// optional .video_widevine.DTCPUsageRules.RetentionState retention_state = 4;
inline bool DTCPUsageRules::_internal_has_retention_state() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_retention_state() const {
  return _internal_has_retention_state();
}
inline void DTCPUsageRules::clear_retention_state() {
  retention_state_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::video_widevine::DTCPUsageRules_RetentionState DTCPUsageRules::_internal_retention_state() const {
  return static_cast< ::video_widevine::DTCPUsageRules_RetentionState >(retention_state_);
}
inline ::video_widevine::DTCPUsageRules_RetentionState DTCPUsageRules::retention_state() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.retention_state)
  return _internal_retention_state();
}
inline void DTCPUsageRules::_internal_set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value) {
  assert(::video_widevine::DTCPUsageRules_RetentionState_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  retention_state_ = value;
}
inline void DTCPUsageRules::set_retention_state(::video_widevine::DTCPUsageRules_RetentionState value) {
  _internal_set_retention_state(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.retention_state)
}

// optional .video_widevine.DTCPUsageRules.AnalogProtectionSystem analog_protection_system = 5;
inline bool DTCPUsageRules::_internal_has_analog_protection_system() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_analog_protection_system() const {
  return _internal_has_analog_protection_system();
}
inline void DTCPUsageRules::clear_analog_protection_system() {
  analog_protection_system_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::video_widevine::DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules::_internal_analog_protection_system() const {
  return static_cast< ::video_widevine::DTCPUsageRules_AnalogProtectionSystem >(analog_protection_system_);
}
inline ::video_widevine::DTCPUsageRules_AnalogProtectionSystem DTCPUsageRules::analog_protection_system() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.analog_protection_system)
  return _internal_analog_protection_system();
}
inline void DTCPUsageRules::_internal_set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value) {
  assert(::video_widevine::DTCPUsageRules_AnalogProtectionSystem_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  analog_protection_system_ = value;
}
inline void DTCPUsageRules::set_analog_protection_system(::video_widevine::DTCPUsageRules_AnalogProtectionSystem value) {
  _internal_set_analog_protection_system(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.analog_protection_system)
}

// optional .video_widevine.DTCPUsageRules.ImageConstraintToken image_constraint_token = 6;
inline bool DTCPUsageRules::_internal_has_image_constraint_token() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_image_constraint_token() const {
  return _internal_has_image_constraint_token();
}
inline void DTCPUsageRules::clear_image_constraint_token() {
  image_constraint_token_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::video_widevine::DTCPUsageRules_ImageConstraintToken DTCPUsageRules::_internal_image_constraint_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_ImageConstraintToken >(image_constraint_token_);
}
inline ::video_widevine::DTCPUsageRules_ImageConstraintToken DTCPUsageRules::image_constraint_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.image_constraint_token)
  return _internal_image_constraint_token();
}
inline void DTCPUsageRules::_internal_set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value) {
  assert(::video_widevine::DTCPUsageRules_ImageConstraintToken_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  image_constraint_token_ = value;
}
inline void DTCPUsageRules::set_image_constraint_token(::video_widevine::DTCPUsageRules_ImageConstraintToken value) {
  _internal_set_image_constraint_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.image_constraint_token)
}

// optional .video_widevine.DTCPUsageRules.AnalogSunsetToken analog_sunset_token = 7;
inline bool DTCPUsageRules::_internal_has_analog_sunset_token() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_analog_sunset_token() const {
  return _internal_has_analog_sunset_token();
}
inline void DTCPUsageRules::clear_analog_sunset_token() {
  analog_sunset_token_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::video_widevine::DTCPUsageRules_AnalogSunsetToken DTCPUsageRules::_internal_analog_sunset_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_AnalogSunsetToken >(analog_sunset_token_);
}
inline ::video_widevine::DTCPUsageRules_AnalogSunsetToken DTCPUsageRules::analog_sunset_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.analog_sunset_token)
  return _internal_analog_sunset_token();
}
inline void DTCPUsageRules::_internal_set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value) {
  assert(::video_widevine::DTCPUsageRules_AnalogSunsetToken_IsValid(value));
  _has_bits_[0] |= 0x00000040u;
  analog_sunset_token_ = value;
}
inline void DTCPUsageRules::set_analog_sunset_token(::video_widevine::DTCPUsageRules_AnalogSunsetToken value) {
  _internal_set_analog_sunset_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.analog_sunset_token)
}

// optional .video_widevine.DTCPUsageRules.DigitalOnlyToken digital_only_token = 8;
inline bool DTCPUsageRules::_internal_has_digital_only_token() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_digital_only_token() const {
  return _internal_has_digital_only_token();
}
inline void DTCPUsageRules::clear_digital_only_token() {
  digital_only_token_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline ::video_widevine::DTCPUsageRules_DigitalOnlyToken DTCPUsageRules::_internal_digital_only_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_DigitalOnlyToken >(digital_only_token_);
}
inline ::video_widevine::DTCPUsageRules_DigitalOnlyToken DTCPUsageRules::digital_only_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.digital_only_token)
  return _internal_digital_only_token();
}
inline void DTCPUsageRules::_internal_set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value) {
  assert(::video_widevine::DTCPUsageRules_DigitalOnlyToken_IsValid(value));
  _has_bits_[0] |= 0x00000080u;
  digital_only_token_ = value;
}
inline void DTCPUsageRules::set_digital_only_token(::video_widevine::DTCPUsageRules_DigitalOnlyToken value) {
  _internal_set_digital_only_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.digital_only_token)
}

// optional .video_widevine.DTCPUsageRules.AudioEnhancedToken audio_enhanced_token = 9;
inline bool DTCPUsageRules::_internal_has_audio_enhanced_token() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_audio_enhanced_token() const {
  return _internal_has_audio_enhanced_token();
}
inline void DTCPUsageRules::clear_audio_enhanced_token() {
  audio_enhanced_token_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::video_widevine::DTCPUsageRules_AudioEnhancedToken DTCPUsageRules::_internal_audio_enhanced_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_AudioEnhancedToken >(audio_enhanced_token_);
}
inline ::video_widevine::DTCPUsageRules_AudioEnhancedToken DTCPUsageRules::audio_enhanced_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.audio_enhanced_token)
  return _internal_audio_enhanced_token();
}
inline void DTCPUsageRules::_internal_set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value) {
  assert(::video_widevine::DTCPUsageRules_AudioEnhancedToken_IsValid(value));
  _has_bits_[0] |= 0x00000100u;
  audio_enhanced_token_ = value;
}
inline void DTCPUsageRules::set_audio_enhanced_token(::video_widevine::DTCPUsageRules_AudioEnhancedToken value) {
  _internal_set_audio_enhanced_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.audio_enhanced_token)
}

// optional uint32 copy_count = 10;
inline bool DTCPUsageRules::_internal_has_copy_count() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_copy_count() const {
  return _internal_has_copy_count();
}
inline void DTCPUsageRules::clear_copy_count() {
  copy_count_ = 0u;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::_internal_copy_count() const {
  return copy_count_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::copy_count() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.copy_count)
  return _internal_copy_count();
}
inline void DTCPUsageRules::_internal_set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000200u;
  copy_count_ = value;
}
inline void DTCPUsageRules::set_copy_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_copy_count(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.copy_count)
}

// optional .video_widevine.DTCPUsageRules.StandardDigitalOutputToken standard_digital_token = 11;
inline bool DTCPUsageRules::_internal_has_standard_digital_token() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_standard_digital_token() const {
  return _internal_has_standard_digital_token();
}
inline void DTCPUsageRules::clear_standard_digital_token() {
  standard_digital_token_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules::_internal_standard_digital_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken >(standard_digital_token_);
}
inline ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken DTCPUsageRules::standard_digital_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.standard_digital_token)
  return _internal_standard_digital_token();
}
inline void DTCPUsageRules::_internal_set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value) {
  assert(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken_IsValid(value));
  _has_bits_[0] |= 0x00000400u;
  standard_digital_token_ = value;
}
inline void DTCPUsageRules::set_standard_digital_token(::video_widevine::DTCPUsageRules_StandardDigitalOutputToken value) {
  _internal_set_standard_digital_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.standard_digital_token)
}

// optional .video_widevine.DTCPUsageRules.HighDynamicRangeToken high_dynamic_token = 12;
inline bool DTCPUsageRules::_internal_has_high_dynamic_token() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_high_dynamic_token() const {
  return _internal_has_high_dynamic_token();
}
inline void DTCPUsageRules::clear_high_dynamic_token() {
  high_dynamic_token_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::video_widevine::DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules::_internal_high_dynamic_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_HighDynamicRangeToken >(high_dynamic_token_);
}
inline ::video_widevine::DTCPUsageRules_HighDynamicRangeToken DTCPUsageRules::high_dynamic_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.high_dynamic_token)
  return _internal_high_dynamic_token();
}
inline void DTCPUsageRules::_internal_set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value) {
  assert(::video_widevine::DTCPUsageRules_HighDynamicRangeToken_IsValid(value));
  _has_bits_[0] |= 0x00000800u;
  high_dynamic_token_ = value;
}
inline void DTCPUsageRules::set_high_dynamic_token(::video_widevine::DTCPUsageRules_HighDynamicRangeToken value) {
  _internal_set_high_dynamic_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.high_dynamic_token)
}

// optional .video_widevine.DTCPUsageRules.L2ProtectionOnlyToken l2_only_token = 13;
inline bool DTCPUsageRules::_internal_has_l2_only_token() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_l2_only_token() const {
  return _internal_has_l2_only_token();
}
inline void DTCPUsageRules::clear_l2_only_token() {
  l2_only_token_ = 0;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules::_internal_l2_only_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken >(l2_only_token_);
}
inline ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken DTCPUsageRules::l2_only_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.l2_only_token)
  return _internal_l2_only_token();
}
inline void DTCPUsageRules::_internal_set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value) {
  assert(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken_IsValid(value));
  _has_bits_[0] |= 0x00001000u;
  l2_only_token_ = value;
}
inline void DTCPUsageRules::set_l2_only_token(::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken value) {
  _internal_set_l2_only_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.l2_only_token)
}

// optional .video_widevine.DTCPUsageRules.EnhancedImageToken enhaned_image_token = 14;
inline bool DTCPUsageRules::_internal_has_enhaned_image_token() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_enhaned_image_token() const {
  return _internal_has_enhaned_image_token();
}
inline void DTCPUsageRules::clear_enhaned_image_token() {
  enhaned_image_token_ = 0;
  _has_bits_[0] &= ~0x00002000u;
}
inline ::video_widevine::DTCPUsageRules_EnhancedImageToken DTCPUsageRules::_internal_enhaned_image_token() const {
  return static_cast< ::video_widevine::DTCPUsageRules_EnhancedImageToken >(enhaned_image_token_);
}
inline ::video_widevine::DTCPUsageRules_EnhancedImageToken DTCPUsageRules::enhaned_image_token() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.enhaned_image_token)
  return _internal_enhaned_image_token();
}
inline void DTCPUsageRules::_internal_set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value) {
  assert(::video_widevine::DTCPUsageRules_EnhancedImageToken_IsValid(value));
  _has_bits_[0] |= 0x00002000u;
  enhaned_image_token_ = value;
}
inline void DTCPUsageRules::set_enhaned_image_token(::video_widevine::DTCPUsageRules_EnhancedImageToken value) {
  _internal_set_enhaned_image_token(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.enhaned_image_token)
}

// optional uint32 retention_time = 15;
inline bool DTCPUsageRules::_internal_has_retention_time() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_retention_time() const {
  return _internal_has_retention_time();
}
inline void DTCPUsageRules::clear_retention_time() {
  retention_time_ = 0u;
  _has_bits_[0] &= ~0x00004000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::_internal_retention_time() const {
  return retention_time_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DTCPUsageRules::retention_time() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.retention_time)
  return _internal_retention_time();
}
inline void DTCPUsageRules::_internal_set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00004000u;
  retention_time_ = value;
}
inline void DTCPUsageRules::set_retention_time(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_retention_time(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.retention_time)
}

// optional .video_widevine.DTCPUsageRules.FurtherBoundCopy further_copy = 16;
inline bool DTCPUsageRules::_internal_has_further_copy() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool DTCPUsageRules::has_further_copy() const {
  return _internal_has_further_copy();
}
inline void DTCPUsageRules::clear_further_copy() {
  further_copy_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline ::video_widevine::DTCPUsageRules_FurtherBoundCopy DTCPUsageRules::_internal_further_copy() const {
  return static_cast< ::video_widevine::DTCPUsageRules_FurtherBoundCopy >(further_copy_);
}
inline ::video_widevine::DTCPUsageRules_FurtherBoundCopy DTCPUsageRules::further_copy() const {
  // @@protoc_insertion_point(field_get:video_widevine.DTCPUsageRules.further_copy)
  return _internal_further_copy();
}
inline void DTCPUsageRules::_internal_set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value) {
  assert(::video_widevine::DTCPUsageRules_FurtherBoundCopy_IsValid(value));
  _has_bits_[0] |= 0x00008000u;
  further_copy_ = value;
}
inline void DTCPUsageRules::set_further_copy(::video_widevine::DTCPUsageRules_FurtherBoundCopy value) {
  _internal_set_further_copy(value);
  // @@protoc_insertion_point(field_set:video_widevine.DTCPUsageRules.further_copy)
}

#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::DTCPUsageRules_RetentionState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_RetentionState>() {
  return ::video_widevine::DTCPUsageRules_RetentionState_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_CopyControlInfo> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_CopyControlInfo>() {
  return ::video_widevine::DTCPUsageRules_CopyControlInfo_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_AnalogProtectionSystem> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_AnalogProtectionSystem>() {
  return ::video_widevine::DTCPUsageRules_AnalogProtectionSystem_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_ImageConstraintToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_ImageConstraintToken>() {
  return ::video_widevine::DTCPUsageRules_ImageConstraintToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_AnalogSunsetToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_AnalogSunsetToken>() {
  return ::video_widevine::DTCPUsageRules_AnalogSunsetToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_DigitalOnlyToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_DigitalOnlyToken>() {
  return ::video_widevine::DTCPUsageRules_DigitalOnlyToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_AudioEnhancedToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_AudioEnhancedToken>() {
  return ::video_widevine::DTCPUsageRules_AudioEnhancedToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken>() {
  return ::video_widevine::DTCPUsageRules_StandardDigitalOutputToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_HighDynamicRangeToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_HighDynamicRangeToken>() {
  return ::video_widevine::DTCPUsageRules_HighDynamicRangeToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken>() {
  return ::video_widevine::DTCPUsageRules_L2ProtectionOnlyToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_EnhancedImageToken> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_EnhancedImageToken>() {
  return ::video_widevine::DTCPUsageRules_EnhancedImageToken_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DTCPUsageRules_FurtherBoundCopy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DTCPUsageRules_FurtherBoundCopy>() {
  return ::video_widevine::DTCPUsageRules_FurtherBoundCopy_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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