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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_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/unknown_field_set.h>
#include "protos/public/hash_algorithm.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsdk_5fstats_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_2fsdk_5fstats_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsdk_5fstats_2eproto;
namespace video_widevine {
class DeviceLicenseCounterByMake;
struct DeviceLicenseCounterByMakeDefaultTypeInternal;
extern DeviceLicenseCounterByMakeDefaultTypeInternal _DeviceLicenseCounterByMake_default_instance_;
class DeviceLicenseCounterByModel;
struct DeviceLicenseCounterByModelDefaultTypeInternal;
extern DeviceLicenseCounterByModelDefaultTypeInternal _DeviceLicenseCounterByModel_default_instance_;
class DeviceLicenseCounterByStatus;
struct DeviceLicenseCounterByStatusDefaultTypeInternal;
extern DeviceLicenseCounterByStatusDefaultTypeInternal _DeviceLicenseCounterByStatus_default_instance_;
class DeviceLicenseCounterBySystemId;
struct DeviceLicenseCounterBySystemIdDefaultTypeInternal;
extern DeviceLicenseCounterBySystemIdDefaultTypeInternal _DeviceLicenseCounterBySystemId_default_instance_;
class DeviceLicenseCounterRequest;
struct DeviceLicenseCounterRequestDefaultTypeInternal;
extern DeviceLicenseCounterRequestDefaultTypeInternal _DeviceLicenseCounterRequest_default_instance_;
class SignedDeviceLicenseCounterRequest;
struct SignedDeviceLicenseCounterRequestDefaultTypeInternal;
extern SignedDeviceLicenseCounterRequestDefaultTypeInternal _SignedDeviceLicenseCounterRequest_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::DeviceLicenseCounterByMake* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByMake>(Arena*);
template<> ::video_widevine::DeviceLicenseCounterByModel* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByModel>(Arena*);
template<> ::video_widevine::DeviceLicenseCounterByStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByStatus>(Arena*);
template<> ::video_widevine::DeviceLicenseCounterBySystemId* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterBySystemId>(Arena*);
template<> ::video_widevine::DeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(Arena*);
template<> ::video_widevine::SignedDeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceLicenseCounterRequest>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

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

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

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

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

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

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

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

  DeviceLicenseCounterByStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceLicenseCounterByStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceLicenseCounterByStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceLicenseCounterByStatus& 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(DeviceLicenseCounterByStatus* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceLicenseCounterByStatus";
  }
  protected:
  explicit DeviceLicenseCounterByStatus(::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 {
    kCountFieldNumber = 2,
    kLicenseStatusFieldNumber = 1,
  };
  // optional int64 count = 2;
  bool has_count() const;
  private:
  bool _internal_has_count() const;
  public:
  void clear_count();
  ::PROTOBUF_NAMESPACE_ID::int64 count() const;
  void set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_count() const;
  void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int32 license_status = 1;
  bool has_license_status() const;
  private:
  bool _internal_has_license_status() const;
  public:
  void clear_license_status();
  ::PROTOBUF_NAMESPACE_ID::int32 license_status() const;
  void set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_license_status() const;
  void _internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByStatus)
 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 count_;
  ::PROTOBUF_NAMESPACE_ID::int32 license_status_;
  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeviceLicenseCounterByModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceLicenseCounterByModel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceLicenseCounterByModel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceLicenseCounterByModel& 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(DeviceLicenseCounterByModel* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceLicenseCounterByModel";
  }
  protected:
  explicit DeviceLicenseCounterByModel(::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 {
    kCounterByStatusFieldNumber = 2,
    kDeviceModelFieldNumber = 1,
  };
  // repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
  int counter_by_status_size() const;
  private:
  int _internal_counter_by_status_size() const;
  public:
  void clear_counter_by_status();
  ::video_widevine::DeviceLicenseCounterByStatus* mutable_counter_by_status(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
      mutable_counter_by_status();
  private:
  const ::video_widevine::DeviceLicenseCounterByStatus& _internal_counter_by_status(int index) const;
  ::video_widevine::DeviceLicenseCounterByStatus* _internal_add_counter_by_status();
  public:
  const ::video_widevine::DeviceLicenseCounterByStatus& counter_by_status(int index) const;
  ::video_widevine::DeviceLicenseCounterByStatus* add_counter_by_status();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
      counter_by_status() const;

  // optional string device_model = 1;
  bool has_device_model() const;
  private:
  bool _internal_has_device_model() const;
  public:
  void clear_device_model();
  const std::string& device_model() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_model(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_model();
  PROTOBUF_MUST_USE_RESULT std::string* release_device_model();
  void set_allocated_device_model(std::string* device_model);
  private:
  const std::string& _internal_device_model() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model(const std::string& value);
  std::string* _internal_mutable_device_model();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByModel)
 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::DeviceLicenseCounterByStatus > counter_by_status_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_model_;
  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeviceLicenseCounterByMake* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceLicenseCounterByMake>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceLicenseCounterByMake& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceLicenseCounterByMake& 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(DeviceLicenseCounterByMake* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceLicenseCounterByMake";
  }
  protected:
  explicit DeviceLicenseCounterByMake(::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 {
    kCounterByModelFieldNumber = 2,
    kDeviceMakeFieldNumber = 1,
  };
  // repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
  int counter_by_model_size() const;
  private:
  int _internal_counter_by_model_size() const;
  public:
  void clear_counter_by_model();
  ::video_widevine::DeviceLicenseCounterByModel* mutable_counter_by_model(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
      mutable_counter_by_model();
  private:
  const ::video_widevine::DeviceLicenseCounterByModel& _internal_counter_by_model(int index) const;
  ::video_widevine::DeviceLicenseCounterByModel* _internal_add_counter_by_model();
  public:
  const ::video_widevine::DeviceLicenseCounterByModel& counter_by_model(int index) const;
  ::video_widevine::DeviceLicenseCounterByModel* add_counter_by_model();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
      counter_by_model() const;

  // optional string device_make = 1;
  bool has_device_make() const;
  private:
  bool _internal_has_device_make() const;
  public:
  void clear_device_make();
  const std::string& device_make() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_make(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_make();
  PROTOBUF_MUST_USE_RESULT std::string* release_device_make();
  void set_allocated_device_make(std::string* device_make);
  private:
  const std::string& _internal_device_make() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_make(const std::string& value);
  std::string* _internal_mutable_device_make();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByMake)
 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::DeviceLicenseCounterByModel > counter_by_model_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_make_;
  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeviceLicenseCounterBySystemId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceLicenseCounterBySystemId>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceLicenseCounterBySystemId& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceLicenseCounterBySystemId& 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(DeviceLicenseCounterBySystemId* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceLicenseCounterBySystemId";
  }
  protected:
  explicit DeviceLicenseCounterBySystemId(::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 {
    kCounterByMakeFieldNumber = 2,
    kDeviceSystemIdFieldNumber = 1,
  };
  // repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
  int counter_by_make_size() const;
  private:
  int _internal_counter_by_make_size() const;
  public:
  void clear_counter_by_make();
  ::video_widevine::DeviceLicenseCounterByMake* mutable_counter_by_make(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
      mutable_counter_by_make();
  private:
  const ::video_widevine::DeviceLicenseCounterByMake& _internal_counter_by_make(int index) const;
  ::video_widevine::DeviceLicenseCounterByMake* _internal_add_counter_by_make();
  public:
  const ::video_widevine::DeviceLicenseCounterByMake& counter_by_make(int index) const;
  ::video_widevine::DeviceLicenseCounterByMake* add_counter_by_make();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
      counter_by_make() const;

  // optional int32 device_system_id = 1;
  bool has_device_system_id() const;
  private:
  bool _internal_has_device_system_id() const;
  public:
  void clear_device_system_id();
  ::PROTOBUF_NAMESPACE_ID::int32 device_system_id() const;
  void set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_system_id() const;
  void _internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterBySystemId)
 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::DeviceLicenseCounterByMake > counter_by_make_;
  ::PROTOBUF_NAMESPACE_ID::int32 device_system_id_;
  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceLicenseCounterRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceLicenseCounterRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceLicenseCounterRequest& 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(DeviceLicenseCounterRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceLicenseCounterRequest";
  }
  protected:
  explicit DeviceLicenseCounterRequest(::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 {
    kCounterBySystemidFieldNumber = 4,
    kProviderFieldNumber = 1,
    kCounterUtcStartTimeUsecFieldNumber = 2,
    kCounterUtcEndTimeUsecFieldNumber = 3,
  };
  // repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
  int counter_by_systemid_size() const;
  private:
  int _internal_counter_by_systemid_size() const;
  public:
  void clear_counter_by_systemid();
  ::video_widevine::DeviceLicenseCounterBySystemId* mutable_counter_by_systemid(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
      mutable_counter_by_systemid();
  private:
  const ::video_widevine::DeviceLicenseCounterBySystemId& _internal_counter_by_systemid(int index) const;
  ::video_widevine::DeviceLicenseCounterBySystemId* _internal_add_counter_by_systemid();
  public:
  const ::video_widevine::DeviceLicenseCounterBySystemId& counter_by_systemid(int index) const;
  ::video_widevine::DeviceLicenseCounterBySystemId* add_counter_by_systemid();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
      counter_by_systemid() const;

  // optional string provider = 1;
  bool has_provider() const;
  private:
  bool _internal_has_provider() const;
  public:
  void clear_provider();
  const std::string& provider() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_provider(ArgT0&& arg0, ArgT... args);
  std::string* mutable_provider();
  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
  void set_allocated_provider(std::string* provider);
  private:
  const std::string& _internal_provider() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
  std::string* _internal_mutable_provider();
  public:

  // optional int64 counter_utc_start_time_usec = 2;
  bool has_counter_utc_start_time_usec() const;
  private:
  bool _internal_has_counter_utc_start_time_usec() const;
  public:
  void clear_counter_utc_start_time_usec();
  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec() const;
  void set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_start_time_usec() const;
  void _internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 counter_utc_end_time_usec = 3;
  bool has_counter_utc_end_time_usec() const;
  private:
  bool _internal_has_counter_utc_end_time_usec() const;
  public:
  void clear_counter_utc_end_time_usec();
  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec() const;
  void set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_end_time_usec() const;
  void _internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterRequest)
 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::DeviceLicenseCounterBySystemId > counter_by_systemid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec_;
  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec_;
  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  SignedDeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SignedDeviceLicenseCounterRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SignedDeviceLicenseCounterRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SignedDeviceLicenseCounterRequest& 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(SignedDeviceLicenseCounterRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.SignedDeviceLicenseCounterRequest";
  }
  protected:
  explicit SignedDeviceLicenseCounterRequest(::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 {
    kSignatureFieldNumber = 2,
    kDeviceLicenseCounterRequestFieldNumber = 1,
    kHashAlgorithmFieldNumber = 3,
  };
  // optional bytes signature = 2;
  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 .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
  bool has_device_license_counter_request() const;
  private:
  bool _internal_has_device_license_counter_request() const;
  public:
  void clear_device_license_counter_request();
  const ::video_widevine::DeviceLicenseCounterRequest& device_license_counter_request() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceLicenseCounterRequest* release_device_license_counter_request();
  ::video_widevine::DeviceLicenseCounterRequest* mutable_device_license_counter_request();
  void set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
  private:
  const ::video_widevine::DeviceLicenseCounterRequest& _internal_device_license_counter_request() const;
  ::video_widevine::DeviceLicenseCounterRequest* _internal_mutable_device_license_counter_request();
  public:
  void unsafe_arena_set_allocated_device_license_counter_request(
      ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
  ::video_widevine::DeviceLicenseCounterRequest* unsafe_arena_release_device_license_counter_request();

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

  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceLicenseCounterRequest)
 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 signature_;
  ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request_;
  int hash_algorithm_;
  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
};
// ===================================================================


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

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

// optional int32 license_status = 1;
inline bool DeviceLicenseCounterByStatus::_internal_has_license_status() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceLicenseCounterByStatus::has_license_status() const {
  return _internal_has_license_status();
}
inline void DeviceLicenseCounterByStatus::clear_license_status() {
  license_status_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::_internal_license_status() const {
  return license_status_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::license_status() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.license_status)
  return _internal_license_status();
}
inline void DeviceLicenseCounterByStatus::_internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  license_status_ = value;
}
inline void DeviceLicenseCounterByStatus::set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_license_status(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.license_status)
}

// optional int64 count = 2;
inline bool DeviceLicenseCounterByStatus::_internal_has_count() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceLicenseCounterByStatus::has_count() const {
  return _internal_has_count();
}
inline void DeviceLicenseCounterByStatus::clear_count() {
  count_ = int64_t{0};
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::_internal_count() const {
  return count_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::count() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.count)
  return _internal_count();
}
inline void DeviceLicenseCounterByStatus::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  count_ = value;
}
inline void DeviceLicenseCounterByStatus::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.count)
}

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

// DeviceLicenseCounterByModel

// optional string device_model = 1;
inline bool DeviceLicenseCounterByModel::_internal_has_device_model() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceLicenseCounterByModel::has_device_model() const {
  return _internal_has_device_model();
}
inline void DeviceLicenseCounterByModel::clear_device_model() {
  device_model_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceLicenseCounterByModel::device_model() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.device_model)
  return _internal_device_model();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceLicenseCounterByModel::set_device_model(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByModel.device_model)
}
inline std::string* DeviceLicenseCounterByModel::mutable_device_model() {
  std::string* _s = _internal_mutable_device_model();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.device_model)
  return _s;
}
inline const std::string& DeviceLicenseCounterByModel::_internal_device_model() const {
  return device_model_.Get();
}
inline void DeviceLicenseCounterByModel::_internal_set_device_model(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceLicenseCounterByModel::_internal_mutable_device_model() {
  _has_bits_[0] |= 0x00000001u;
  return device_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceLicenseCounterByModel::release_device_model() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByModel.device_model)
  if (!_internal_has_device_model()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return device_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceLicenseCounterByModel::set_allocated_device_model(std::string* device_model) {
  if (device_model != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  device_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_model,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByModel.device_model)
}

// repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
inline int DeviceLicenseCounterByModel::_internal_counter_by_status_size() const {
  return counter_by_status_.size();
}
inline int DeviceLicenseCounterByModel::counter_by_status_size() const {
  return _internal_counter_by_status_size();
}
inline void DeviceLicenseCounterByModel::clear_counter_by_status() {
  counter_by_status_.Clear();
}
inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::mutable_counter_by_status(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
  return counter_by_status_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
DeviceLicenseCounterByModel::mutable_counter_by_status() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
  return &counter_by_status_;
}
inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::_internal_counter_by_status(int index) const {
  return counter_by_status_.Get(index);
}
inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::counter_by_status(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
  return _internal_counter_by_status(index);
}
inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::_internal_add_counter_by_status() {
  return counter_by_status_.Add();
}
inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::add_counter_by_status() {
  ::video_widevine::DeviceLicenseCounterByStatus* _add = _internal_add_counter_by_status();
  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
DeviceLicenseCounterByModel::counter_by_status() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
  return counter_by_status_;
}

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

// DeviceLicenseCounterByMake

// optional string device_make = 1;
inline bool DeviceLicenseCounterByMake::_internal_has_device_make() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceLicenseCounterByMake::has_device_make() const {
  return _internal_has_device_make();
}
inline void DeviceLicenseCounterByMake::clear_device_make() {
  device_make_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceLicenseCounterByMake::device_make() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.device_make)
  return _internal_device_make();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceLicenseCounterByMake::set_device_make(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByMake.device_make)
}
inline std::string* DeviceLicenseCounterByMake::mutable_device_make() {
  std::string* _s = _internal_mutable_device_make();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.device_make)
  return _s;
}
inline const std::string& DeviceLicenseCounterByMake::_internal_device_make() const {
  return device_make_.Get();
}
inline void DeviceLicenseCounterByMake::_internal_set_device_make(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceLicenseCounterByMake::_internal_mutable_device_make() {
  _has_bits_[0] |= 0x00000001u;
  return device_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceLicenseCounterByMake::release_device_make() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByMake.device_make)
  if (!_internal_has_device_make()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return device_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceLicenseCounterByMake::set_allocated_device_make(std::string* device_make) {
  if (device_make != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  device_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_make,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByMake.device_make)
}

// repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
inline int DeviceLicenseCounterByMake::_internal_counter_by_model_size() const {
  return counter_by_model_.size();
}
inline int DeviceLicenseCounterByMake::counter_by_model_size() const {
  return _internal_counter_by_model_size();
}
inline void DeviceLicenseCounterByMake::clear_counter_by_model() {
  counter_by_model_.Clear();
}
inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::mutable_counter_by_model(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
  return counter_by_model_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
DeviceLicenseCounterByMake::mutable_counter_by_model() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
  return &counter_by_model_;
}
inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::_internal_counter_by_model(int index) const {
  return counter_by_model_.Get(index);
}
inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::counter_by_model(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
  return _internal_counter_by_model(index);
}
inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::_internal_add_counter_by_model() {
  return counter_by_model_.Add();
}
inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::add_counter_by_model() {
  ::video_widevine::DeviceLicenseCounterByModel* _add = _internal_add_counter_by_model();
  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
DeviceLicenseCounterByMake::counter_by_model() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
  return counter_by_model_;
}

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

// DeviceLicenseCounterBySystemId

// optional int32 device_system_id = 1;
inline bool DeviceLicenseCounterBySystemId::_internal_has_device_system_id() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceLicenseCounterBySystemId::has_device_system_id() const {
  return _internal_has_device_system_id();
}
inline void DeviceLicenseCounterBySystemId::clear_device_system_id() {
  device_system_id_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::_internal_device_system_id() const {
  return device_system_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::device_system_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
  return _internal_device_system_id();
}
inline void DeviceLicenseCounterBySystemId::_internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000001u;
  device_system_id_ = value;
}
inline void DeviceLicenseCounterBySystemId::set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_device_system_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
}

// repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
inline int DeviceLicenseCounterBySystemId::_internal_counter_by_make_size() const {
  return counter_by_make_.size();
}
inline int DeviceLicenseCounterBySystemId::counter_by_make_size() const {
  return _internal_counter_by_make_size();
}
inline void DeviceLicenseCounterBySystemId::clear_counter_by_make() {
  counter_by_make_.Clear();
}
inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::mutable_counter_by_make(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
  return counter_by_make_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
DeviceLicenseCounterBySystemId::mutable_counter_by_make() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
  return &counter_by_make_;
}
inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::_internal_counter_by_make(int index) const {
  return counter_by_make_.Get(index);
}
inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::counter_by_make(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
  return _internal_counter_by_make(index);
}
inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::_internal_add_counter_by_make() {
  return counter_by_make_.Add();
}
inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::add_counter_by_make() {
  ::video_widevine::DeviceLicenseCounterByMake* _add = _internal_add_counter_by_make();
  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
DeviceLicenseCounterBySystemId::counter_by_make() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
  return counter_by_make_;
}

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

// DeviceLicenseCounterRequest

// optional string provider = 1;
inline bool DeviceLicenseCounterRequest::_internal_has_provider() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceLicenseCounterRequest::has_provider() const {
  return _internal_has_provider();
}
inline void DeviceLicenseCounterRequest::clear_provider() {
  provider_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceLicenseCounterRequest::provider() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.provider)
  return _internal_provider();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceLicenseCounterRequest::set_provider(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.provider)
}
inline std::string* DeviceLicenseCounterRequest::mutable_provider() {
  std::string* _s = _internal_mutable_provider();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.provider)
  return _s;
}
inline const std::string& DeviceLicenseCounterRequest::_internal_provider() const {
  return provider_.Get();
}
inline void DeviceLicenseCounterRequest::_internal_set_provider(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceLicenseCounterRequest::_internal_mutable_provider() {
  _has_bits_[0] |= 0x00000001u;
  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceLicenseCounterRequest::release_provider() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterRequest.provider)
  if (!_internal_has_provider()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceLicenseCounterRequest::set_allocated_provider(std::string* provider) {
  if (provider != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterRequest.provider)
}

// optional int64 counter_utc_start_time_usec = 2;
inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_start_time_usec() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceLicenseCounterRequest::has_counter_utc_start_time_usec() const {
  return _internal_has_counter_utc_start_time_usec();
}
inline void DeviceLicenseCounterRequest::clear_counter_utc_start_time_usec() {
  counter_utc_start_time_usec_ = int64_t{0};
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_start_time_usec() const {
  return counter_utc_start_time_usec_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_start_time_usec() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
  return _internal_counter_utc_start_time_usec();
}
inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  counter_utc_start_time_usec_ = value;
}
inline void DeviceLicenseCounterRequest::set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_counter_utc_start_time_usec(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
}

// optional int64 counter_utc_end_time_usec = 3;
inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_end_time_usec() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DeviceLicenseCounterRequest::has_counter_utc_end_time_usec() const {
  return _internal_has_counter_utc_end_time_usec();
}
inline void DeviceLicenseCounterRequest::clear_counter_utc_end_time_usec() {
  counter_utc_end_time_usec_ = int64_t{0};
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_end_time_usec() const {
  return counter_utc_end_time_usec_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_end_time_usec() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
  return _internal_counter_utc_end_time_usec();
}
inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  counter_utc_end_time_usec_ = value;
}
inline void DeviceLicenseCounterRequest::set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_counter_utc_end_time_usec(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
}

// repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
inline int DeviceLicenseCounterRequest::_internal_counter_by_systemid_size() const {
  return counter_by_systemid_.size();
}
inline int DeviceLicenseCounterRequest::counter_by_systemid_size() const {
  return _internal_counter_by_systemid_size();
}
inline void DeviceLicenseCounterRequest::clear_counter_by_systemid() {
  counter_by_systemid_.Clear();
}
inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::mutable_counter_by_systemid(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
  return counter_by_systemid_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
DeviceLicenseCounterRequest::mutable_counter_by_systemid() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
  return &counter_by_systemid_;
}
inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::_internal_counter_by_systemid(int index) const {
  return counter_by_systemid_.Get(index);
}
inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::counter_by_systemid(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
  return _internal_counter_by_systemid(index);
}
inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::_internal_add_counter_by_systemid() {
  return counter_by_systemid_.Add();
}
inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::add_counter_by_systemid() {
  ::video_widevine::DeviceLicenseCounterBySystemId* _add = _internal_add_counter_by_systemid();
  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
DeviceLicenseCounterRequest::counter_by_systemid() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
  return counter_by_systemid_;
}

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

// SignedDeviceLicenseCounterRequest

// optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
inline bool SignedDeviceLicenseCounterRequest::_internal_has_device_license_counter_request() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || device_license_counter_request_ != nullptr);
  return value;
}
inline bool SignedDeviceLicenseCounterRequest::has_device_license_counter_request() const {
  return _internal_has_device_license_counter_request();
}
inline void SignedDeviceLicenseCounterRequest::clear_device_license_counter_request() {
  if (device_license_counter_request_ != nullptr) device_license_counter_request_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::_internal_device_license_counter_request() const {
  const ::video_widevine::DeviceLicenseCounterRequest* p = device_license_counter_request_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceLicenseCounterRequest&>(
      ::video_widevine::_DeviceLicenseCounterRequest_default_instance_);
}
inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::device_license_counter_request() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
  return _internal_device_license_counter_request();
}
inline void SignedDeviceLicenseCounterRequest::unsafe_arena_set_allocated_device_license_counter_request(
    ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_license_counter_request_);
  }
  device_license_counter_request_ = device_license_counter_request;
  if (device_license_counter_request) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
}
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::release_device_license_counter_request() {
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
  device_license_counter_request_ = 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::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::unsafe_arena_release_device_license_counter_request() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
  _has_bits_[0] &= ~0x00000002u;
  ::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
  device_license_counter_request_ = nullptr;
  return temp;
}
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::_internal_mutable_device_license_counter_request() {
  _has_bits_[0] |= 0x00000002u;
  if (device_license_counter_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(GetArenaForAllocation());
    device_license_counter_request_ = p;
  }
  return device_license_counter_request_;
}
inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::mutable_device_license_counter_request() {
  ::video_widevine::DeviceLicenseCounterRequest* _msg = _internal_mutable_device_license_counter_request();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
  return _msg;
}
inline void SignedDeviceLicenseCounterRequest::set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete device_license_counter_request_;
  }
  if (device_license_counter_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceLicenseCounterRequest>::GetOwningArena(device_license_counter_request);
    if (message_arena != submessage_arena) {
      device_license_counter_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_license_counter_request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  device_license_counter_request_ = device_license_counter_request;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
}

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

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

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace video_widevine

// @@protoc_insertion_point(global_scope)

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