// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: safebrowsing_v5.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_safebrowsing_5fv5_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_safebrowsing_5fv5_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021006 < 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_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_safebrowsing_5fv5_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_safebrowsing_5fv5_2eproto {
  static const uint32_t offsets[];
};
namespace mozilla {
namespace safebrowsing {
namespace v5 {
class BatchGetHashListsRequest;
struct BatchGetHashListsRequestDefaultTypeInternal;
extern BatchGetHashListsRequestDefaultTypeInternal _BatchGetHashListsRequest_default_instance_;
class BatchGetHashListsResponse;
struct BatchGetHashListsResponseDefaultTypeInternal;
extern BatchGetHashListsResponseDefaultTypeInternal _BatchGetHashListsResponse_default_instance_;
class Duration;
struct DurationDefaultTypeInternal;
extern DurationDefaultTypeInternal _Duration_default_instance_;
class FullHash;
struct FullHashDefaultTypeInternal;
extern FullHashDefaultTypeInternal _FullHash_default_instance_;
class FullHash_FullHashDetail;
struct FullHash_FullHashDetailDefaultTypeInternal;
extern FullHash_FullHashDetailDefaultTypeInternal _FullHash_FullHashDetail_default_instance_;
class GetHashListRequest;
struct GetHashListRequestDefaultTypeInternal;
extern GetHashListRequestDefaultTypeInternal _GetHashListRequest_default_instance_;
class HashList;
struct HashListDefaultTypeInternal;
extern HashListDefaultTypeInternal _HashList_default_instance_;
class HashListMetadata;
struct HashListMetadataDefaultTypeInternal;
extern HashListMetadataDefaultTypeInternal _HashListMetadata_default_instance_;
class ListHashListsRequest;
struct ListHashListsRequestDefaultTypeInternal;
extern ListHashListsRequestDefaultTypeInternal _ListHashListsRequest_default_instance_;
class ListHashListsResponse;
struct ListHashListsResponseDefaultTypeInternal;
extern ListHashListsResponseDefaultTypeInternal _ListHashListsResponse_default_instance_;
class RiceDeltaEncoded128Bit;
struct RiceDeltaEncoded128BitDefaultTypeInternal;
extern RiceDeltaEncoded128BitDefaultTypeInternal _RiceDeltaEncoded128Bit_default_instance_;
class RiceDeltaEncoded256Bit;
struct RiceDeltaEncoded256BitDefaultTypeInternal;
extern RiceDeltaEncoded256BitDefaultTypeInternal _RiceDeltaEncoded256Bit_default_instance_;
class RiceDeltaEncoded32Bit;
struct RiceDeltaEncoded32BitDefaultTypeInternal;
extern RiceDeltaEncoded32BitDefaultTypeInternal _RiceDeltaEncoded32Bit_default_instance_;
class RiceDeltaEncoded64Bit;
struct RiceDeltaEncoded64BitDefaultTypeInternal;
extern RiceDeltaEncoded64BitDefaultTypeInternal _RiceDeltaEncoded64Bit_default_instance_;
class SearchHashesRequest;
struct SearchHashesRequestDefaultTypeInternal;
extern SearchHashesRequestDefaultTypeInternal _SearchHashesRequest_default_instance_;
class SearchHashesResponse;
struct SearchHashesResponseDefaultTypeInternal;
extern SearchHashesResponseDefaultTypeInternal _SearchHashesResponse_default_instance_;
class SizeConstraints;
struct SizeConstraintsDefaultTypeInternal;
extern SizeConstraintsDefaultTypeInternal _SizeConstraints_default_instance_;
}  // namespace v5
}  // namespace safebrowsing
}  // namespace mozilla
PROTOBUF_NAMESPACE_OPEN
template<> ::mozilla::safebrowsing::v5::BatchGetHashListsRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::BatchGetHashListsRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::BatchGetHashListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::BatchGetHashListsResponse>(Arena*);
template<> ::mozilla::safebrowsing::v5::Duration* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::Duration>(Arena*);
template<> ::mozilla::safebrowsing::v5::FullHash* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::FullHash>(Arena*);
template<> ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::FullHash_FullHashDetail>(Arena*);
template<> ::mozilla::safebrowsing::v5::GetHashListRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::GetHashListRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::HashList* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::HashList>(Arena*);
template<> ::mozilla::safebrowsing::v5::HashListMetadata* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::HashListMetadata>(Arena*);
template<> ::mozilla::safebrowsing::v5::ListHashListsRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::ListHashListsRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::ListHashListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::ListHashListsResponse>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit>(Arena*);
template<> ::mozilla::safebrowsing::v5::SearchHashesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::SearchHashesRequest>(Arena*);
template<> ::mozilla::safebrowsing::v5::SearchHashesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::SearchHashesResponse>(Arena*);
template<> ::mozilla::safebrowsing::v5::SizeConstraints* Arena::CreateMaybeMessage<::mozilla::safebrowsing::v5::SizeConstraints>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace mozilla {
namespace safebrowsing {
namespace v5 {

enum HashListMetadata_HashLength : int {
  HashListMetadata_HashLength_HASH_LENGTH_UNSPECIFIED = 0,
  HashListMetadata_HashLength_FOUR_BYTES = 2,
  HashListMetadata_HashLength_EIGHT_BYTES = 3,
  HashListMetadata_HashLength_SIXTEEN_BYTES = 4,
  HashListMetadata_HashLength_THIRTY_TWO_BYTES = 5,
  HashListMetadata_HashLength_HashListMetadata_HashLength_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  HashListMetadata_HashLength_HashListMetadata_HashLength_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool HashListMetadata_HashLength_IsValid(int value);
constexpr HashListMetadata_HashLength HashListMetadata_HashLength_HashLength_MIN = HashListMetadata_HashLength_HASH_LENGTH_UNSPECIFIED;
constexpr HashListMetadata_HashLength HashListMetadata_HashLength_HashLength_MAX = HashListMetadata_HashLength_THIRTY_TWO_BYTES;
constexpr int HashListMetadata_HashLength_HashLength_ARRAYSIZE = HashListMetadata_HashLength_HashLength_MAX + 1;

const std::string& HashListMetadata_HashLength_Name(HashListMetadata_HashLength value);
template<typename T>
inline const std::string& HashListMetadata_HashLength_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HashListMetadata_HashLength>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HashListMetadata_HashLength_Name.");
  return HashListMetadata_HashLength_Name(static_cast<HashListMetadata_HashLength>(enum_t_value));
}
bool HashListMetadata_HashLength_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HashListMetadata_HashLength* value);
enum ThreatType : int {
  THREAT_TYPE_UNSPECIFIED = 0,
  MALWARE = 1,
  SOCIAL_ENGINEERING = 2,
  UNWANTED_SOFTWARE = 3,
  POTENTIALLY_HARMFUL_APPLICATION = 4,
  ThreatType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ThreatType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ThreatType_IsValid(int value);
constexpr ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED;
constexpr ThreatType ThreatType_MAX = POTENTIALLY_HARMFUL_APPLICATION;
constexpr int ThreatType_ARRAYSIZE = ThreatType_MAX + 1;

const std::string& ThreatType_Name(ThreatType value);
template<typename T>
inline const std::string& ThreatType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ThreatType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ThreatType_Name.");
  return ThreatType_Name(static_cast<ThreatType>(enum_t_value));
}
bool ThreatType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatType* value);
enum LikelySafeType : int {
  LIKELY_SAFE_TYPE_UNSPECIFIED = 0,
  GENERAL_BROWSING = 1,
  CSD = 2,
  DOWNLOAD = 3,
  LikelySafeType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  LikelySafeType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool LikelySafeType_IsValid(int value);
constexpr LikelySafeType LikelySafeType_MIN = LIKELY_SAFE_TYPE_UNSPECIFIED;
constexpr LikelySafeType LikelySafeType_MAX = DOWNLOAD;
constexpr int LikelySafeType_ARRAYSIZE = LikelySafeType_MAX + 1;

const std::string& LikelySafeType_Name(LikelySafeType value);
template<typename T>
inline const std::string& LikelySafeType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LikelySafeType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LikelySafeType_Name.");
  return LikelySafeType_Name(static_cast<LikelySafeType>(enum_t_value));
}
bool LikelySafeType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LikelySafeType* value);
enum ThreatAttribute : int {
  THREAT_ATTRIBUTE_UNSPECIFIED = 0,
  CANARY = 1,
  FRAME_ONLY = 2,
  ThreatAttribute_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ThreatAttribute_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ThreatAttribute_IsValid(int value);
constexpr ThreatAttribute ThreatAttribute_MIN = THREAT_ATTRIBUTE_UNSPECIFIED;
constexpr ThreatAttribute ThreatAttribute_MAX = FRAME_ONLY;
constexpr int ThreatAttribute_ARRAYSIZE = ThreatAttribute_MAX + 1;

const std::string& ThreatAttribute_Name(ThreatAttribute value);
template<typename T>
inline const std::string& ThreatAttribute_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ThreatAttribute>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ThreatAttribute_Name.");
  return ThreatAttribute_Name(static_cast<ThreatAttribute>(enum_t_value));
}
bool ThreatAttribute_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatAttribute* value);
// ===================================================================

class SearchHashesRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.SearchHashesRequest) */ {
 public:
  inline SearchHashesRequest() : SearchHashesRequest(nullptr) {}
  ~SearchHashesRequest() override;
  explicit PROTOBUF_CONSTEXPR SearchHashesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SearchHashesRequest& operator=(const SearchHashesRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchHashesRequest& operator=(SearchHashesRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(SearchHashesRequest& a, SearchHashesRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(SearchHashesRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SearchHashesRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SearchHashesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SearchHashesRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SearchHashesRequest& from);
  void MergeFrom(const SearchHashesRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SearchHashesRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.SearchHashesRequest";
  }
  protected:
  explicit SearchHashesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kHashPrefixesFieldNumber = 1,
  };
  // repeated bytes hash_prefixes = 1;
  int hash_prefixes_size() const;
  private:
  int _internal_hash_prefixes_size() const;
  public:
  void clear_hash_prefixes();
  const std::string& hash_prefixes(int index) const;
  std::string* mutable_hash_prefixes(int index);
  void set_hash_prefixes(int index, const std::string& value);
  void set_hash_prefixes(int index, std::string&& value);
  void set_hash_prefixes(int index, const char* value);
  void set_hash_prefixes(int index, const void* value, size_t size);
  std::string* add_hash_prefixes();
  void add_hash_prefixes(const std::string& value);
  void add_hash_prefixes(std::string&& value);
  void add_hash_prefixes(const char* value);
  void add_hash_prefixes(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& hash_prefixes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_hash_prefixes();
  private:
  const std::string& _internal_hash_prefixes(int index) const;
  std::string* _internal_add_hash_prefixes();
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.SearchHashesRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> hash_prefixes_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class Duration final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.Duration) */ {
 public:
  inline Duration() : Duration(nullptr) {}
  ~Duration() override;
  explicit PROTOBUF_CONSTEXPR Duration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Duration& operator=(const Duration& from) {
    CopyFrom(from);
    return *this;
  }
  inline Duration& operator=(Duration&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(Duration& a, Duration& b) {
    a.Swap(&b);
  }
  inline void Swap(Duration* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Duration* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Duration>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Duration& from);
  void MergeFrom(const Duration& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Duration* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.Duration";
  }
  protected:
  explicit Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kSecondsFieldNumber = 1,
    kNanosFieldNumber = 2,
  };
  // int64 seconds = 1;
  void clear_seconds();
  int64_t seconds() const;
  void set_seconds(int64_t value);
  private:
  int64_t _internal_seconds() const;
  void _internal_set_seconds(int64_t value);
  public:

  // int32 nanos = 2;
  void clear_nanos();
  int32_t nanos() const;
  void set_nanos(int32_t value);
  private:
  int32_t _internal_nanos() const;
  void _internal_set_nanos(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.Duration)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t seconds_;
    int32_t nanos_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class SearchHashesResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.SearchHashesResponse) */ {
 public:
  inline SearchHashesResponse() : SearchHashesResponse(nullptr) {}
  ~SearchHashesResponse() override;
  explicit PROTOBUF_CONSTEXPR SearchHashesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SearchHashesResponse& operator=(const SearchHashesResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchHashesResponse& operator=(SearchHashesResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(SearchHashesResponse& a, SearchHashesResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(SearchHashesResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SearchHashesResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SearchHashesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SearchHashesResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SearchHashesResponse& from);
  void MergeFrom(const SearchHashesResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SearchHashesResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.SearchHashesResponse";
  }
  protected:
  explicit SearchHashesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kFullHashesFieldNumber = 1,
    kCacheDurationFieldNumber = 2,
  };
  // repeated .mozilla.safebrowsing.v5.FullHash full_hashes = 1;
  int full_hashes_size() const;
  private:
  int _internal_full_hashes_size() const;
  public:
  void clear_full_hashes();
  ::mozilla::safebrowsing::v5::FullHash* mutable_full_hashes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >*
      mutable_full_hashes();
  private:
  const ::mozilla::safebrowsing::v5::FullHash& _internal_full_hashes(int index) const;
  ::mozilla::safebrowsing::v5::FullHash* _internal_add_full_hashes();
  public:
  const ::mozilla::safebrowsing::v5::FullHash& full_hashes(int index) const;
  ::mozilla::safebrowsing::v5::FullHash* add_full_hashes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >&
      full_hashes() const;

  // .mozilla.safebrowsing.v5.Duration cache_duration = 2;
  bool has_cache_duration() const;
  private:
  bool _internal_has_cache_duration() const;
  public:
  void clear_cache_duration();
  const ::mozilla::safebrowsing::v5::Duration& cache_duration() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::Duration* release_cache_duration();
  ::mozilla::safebrowsing::v5::Duration* mutable_cache_duration();
  void set_allocated_cache_duration(::mozilla::safebrowsing::v5::Duration* cache_duration);
  private:
  const ::mozilla::safebrowsing::v5::Duration& _internal_cache_duration() const;
  ::mozilla::safebrowsing::v5::Duration* _internal_mutable_cache_duration();
  public:
  void unsafe_arena_set_allocated_cache_duration(
      ::mozilla::safebrowsing::v5::Duration* cache_duration);
  ::mozilla::safebrowsing::v5::Duration* unsafe_arena_release_cache_duration();

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.SearchHashesResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash > full_hashes_;
    ::mozilla::safebrowsing::v5::Duration* cache_duration_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class FullHash_FullHashDetail final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.FullHash.FullHashDetail) */ {
 public:
  inline FullHash_FullHashDetail() : FullHash_FullHashDetail(nullptr) {}
  ~FullHash_FullHashDetail() override;
  explicit PROTOBUF_CONSTEXPR FullHash_FullHashDetail(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FullHash_FullHashDetail& operator=(const FullHash_FullHashDetail& from) {
    CopyFrom(from);
    return *this;
  }
  inline FullHash_FullHashDetail& operator=(FullHash_FullHashDetail&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(FullHash_FullHashDetail& a, FullHash_FullHashDetail& b) {
    a.Swap(&b);
  }
  inline void Swap(FullHash_FullHashDetail* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FullHash_FullHashDetail* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FullHash_FullHashDetail* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FullHash_FullHashDetail>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const FullHash_FullHashDetail& from);
  void MergeFrom(const FullHash_FullHashDetail& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FullHash_FullHashDetail* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.FullHash.FullHashDetail";
  }
  protected:
  explicit FullHash_FullHashDetail(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kAttributesFieldNumber = 2,
    kThreatTypeFieldNumber = 1,
  };
  // repeated .mozilla.safebrowsing.v5.ThreatAttribute attributes = 2;
  int attributes_size() const;
  private:
  int _internal_attributes_size() const;
  public:
  void clear_attributes();
  private:
  ::mozilla::safebrowsing::v5::ThreatAttribute _internal_attributes(int index) const;
  void _internal_add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_attributes();
  public:
  ::mozilla::safebrowsing::v5::ThreatAttribute attributes(int index) const;
  void set_attributes(int index, ::mozilla::safebrowsing::v5::ThreatAttribute value);
  void add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& attributes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_attributes();

  // .mozilla.safebrowsing.v5.ThreatType threat_type = 1;
  void clear_threat_type();
  ::mozilla::safebrowsing::v5::ThreatType threat_type() const;
  void set_threat_type(::mozilla::safebrowsing::v5::ThreatType value);
  private:
  ::mozilla::safebrowsing::v5::ThreatType _internal_threat_type() const;
  void _internal_set_threat_type(::mozilla::safebrowsing::v5::ThreatType value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.FullHash.FullHashDetail)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> attributes_;
    mutable std::atomic<int> _attributes_cached_byte_size_;
    int threat_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class FullHash final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.FullHash) */ {
 public:
  inline FullHash() : FullHash(nullptr) {}
  ~FullHash() override;
  explicit PROTOBUF_CONSTEXPR FullHash(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FullHash& operator=(const FullHash& from) {
    CopyFrom(from);
    return *this;
  }
  inline FullHash& operator=(FullHash&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(FullHash& a, FullHash& b) {
    a.Swap(&b);
  }
  inline void Swap(FullHash* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FullHash* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FullHash* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FullHash>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const FullHash& from);
  void MergeFrom(const FullHash& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FullHash* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.FullHash";
  }
  protected:
  explicit FullHash(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef FullHash_FullHashDetail FullHashDetail;

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

  enum : int {
    kFullHashDetailsFieldNumber = 2,
    kFullHashFieldNumber = 1,
  };
  // repeated .mozilla.safebrowsing.v5.FullHash.FullHashDetail full_hash_details = 2;
  int full_hash_details_size() const;
  private:
  int _internal_full_hash_details_size() const;
  public:
  void clear_full_hash_details();
  ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* mutable_full_hash_details(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >*
      mutable_full_hash_details();
  private:
  const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& _internal_full_hash_details(int index) const;
  ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* _internal_add_full_hash_details();
  public:
  const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& full_hash_details(int index) const;
  ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* add_full_hash_details();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >&
      full_hash_details() const;

  // bytes full_hash = 1;
  void clear_full_hash();
  const std::string& full_hash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_full_hash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_full_hash();
  PROTOBUF_NODISCARD std::string* release_full_hash();
  void set_allocated_full_hash(std::string* full_hash);
  private:
  const std::string& _internal_full_hash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_full_hash(const std::string& value);
  std::string* _internal_mutable_full_hash();
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.FullHash)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail > full_hash_details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr full_hash_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class GetHashListRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.GetHashListRequest) */ {
 public:
  inline GetHashListRequest() : GetHashListRequest(nullptr) {}
  ~GetHashListRequest() override;
  explicit PROTOBUF_CONSTEXPR GetHashListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GetHashListRequest& operator=(const GetHashListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetHashListRequest& operator=(GetHashListRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(GetHashListRequest& a, GetHashListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetHashListRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetHashListRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetHashListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetHashListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetHashListRequest& from);
  void MergeFrom(const GetHashListRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetHashListRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.GetHashListRequest";
  }
  protected:
  explicit GetHashListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
    kVersionFieldNumber = 2,
    kSizeConstraintsFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bytes version = 2;
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
  bool has_size_constraints() const;
  private:
  bool _internal_has_size_constraints() const;
  public:
  void clear_size_constraints();
  const ::mozilla::safebrowsing::v5::SizeConstraints& size_constraints() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::SizeConstraints* release_size_constraints();
  ::mozilla::safebrowsing::v5::SizeConstraints* mutable_size_constraints();
  void set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
  private:
  const ::mozilla::safebrowsing::v5::SizeConstraints& _internal_size_constraints() const;
  ::mozilla::safebrowsing::v5::SizeConstraints* _internal_mutable_size_constraints();
  public:
  void unsafe_arena_set_allocated_size_constraints(
      ::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
  ::mozilla::safebrowsing::v5::SizeConstraints* unsafe_arena_release_size_constraints();

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.GetHashListRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    ::mozilla::safebrowsing::v5::SizeConstraints* size_constraints_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class SizeConstraints final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.SizeConstraints) */ {
 public:
  inline SizeConstraints() : SizeConstraints(nullptr) {}
  ~SizeConstraints() override;
  explicit PROTOBUF_CONSTEXPR SizeConstraints(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SizeConstraints& operator=(const SizeConstraints& from) {
    CopyFrom(from);
    return *this;
  }
  inline SizeConstraints& operator=(SizeConstraints&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SizeConstraints& default_instance() {
    return *internal_default_instance();
  }
  static inline const SizeConstraints* internal_default_instance() {
    return reinterpret_cast<const SizeConstraints*>(
               &_SizeConstraints_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(SizeConstraints& a, SizeConstraints& b) {
    a.Swap(&b);
  }
  inline void Swap(SizeConstraints* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SizeConstraints* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SizeConstraints* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SizeConstraints>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SizeConstraints& from);
  void MergeFrom(const SizeConstraints& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SizeConstraints* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.SizeConstraints";
  }
  protected:
  explicit SizeConstraints(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kMaxUpdateEntriesFieldNumber = 1,
    kMaxDatabaseEntriesFieldNumber = 2,
  };
  // int32 max_update_entries = 1;
  void clear_max_update_entries();
  int32_t max_update_entries() const;
  void set_max_update_entries(int32_t value);
  private:
  int32_t _internal_max_update_entries() const;
  void _internal_set_max_update_entries(int32_t value);
  public:

  // int32 max_database_entries = 2;
  void clear_max_database_entries();
  int32_t max_database_entries() const;
  void set_max_database_entries(int32_t value);
  private:
  int32_t _internal_max_database_entries() const;
  void _internal_set_max_database_entries(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.SizeConstraints)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int32_t max_update_entries_;
    int32_t max_database_entries_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class RiceDeltaEncoded32Bit final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit) */ {
 public:
  inline RiceDeltaEncoded32Bit() : RiceDeltaEncoded32Bit(nullptr) {}
  ~RiceDeltaEncoded32Bit() override;
  explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded32Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RiceDeltaEncoded32Bit& operator=(const RiceDeltaEncoded32Bit& from) {
    CopyFrom(from);
    return *this;
  }
  inline RiceDeltaEncoded32Bit& operator=(RiceDeltaEncoded32Bit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RiceDeltaEncoded32Bit& default_instance() {
    return *internal_default_instance();
  }
  static inline const RiceDeltaEncoded32Bit* internal_default_instance() {
    return reinterpret_cast<const RiceDeltaEncoded32Bit*>(
               &_RiceDeltaEncoded32Bit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(RiceDeltaEncoded32Bit& a, RiceDeltaEncoded32Bit& b) {
    a.Swap(&b);
  }
  inline void Swap(RiceDeltaEncoded32Bit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RiceDeltaEncoded32Bit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RiceDeltaEncoded32Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RiceDeltaEncoded32Bit>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RiceDeltaEncoded32Bit& from);
  void MergeFrom(const RiceDeltaEncoded32Bit& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RiceDeltaEncoded32Bit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit";
  }
  protected:
  explicit RiceDeltaEncoded32Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kEncodedDataFieldNumber = 4,
    kFirstValueFieldNumber = 1,
    kRiceParameterFieldNumber = 2,
    kEntriesCountFieldNumber = 3,
  };
  // bytes encoded_data = 4;
  void clear_encoded_data();
  const std::string& encoded_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encoded_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encoded_data();
  PROTOBUF_NODISCARD std::string* release_encoded_data();
  void set_allocated_encoded_data(std::string* encoded_data);
  private:
  const std::string& _internal_encoded_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
  std::string* _internal_mutable_encoded_data();
  public:

  // uint32 first_value = 1;
  void clear_first_value();
  uint32_t first_value() const;
  void set_first_value(uint32_t value);
  private:
  uint32_t _internal_first_value() const;
  void _internal_set_first_value(uint32_t value);
  public:

  // int32 rice_parameter = 2;
  void clear_rice_parameter();
  int32_t rice_parameter() const;
  void set_rice_parameter(int32_t value);
  private:
  int32_t _internal_rice_parameter() const;
  void _internal_set_rice_parameter(int32_t value);
  public:

  // int32 entries_count = 3;
  void clear_entries_count();
  int32_t entries_count() const;
  void set_entries_count(int32_t value);
  private:
  int32_t _internal_entries_count() const;
  void _internal_set_entries_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
    uint32_t first_value_;
    int32_t rice_parameter_;
    int32_t entries_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class RiceDeltaEncoded64Bit final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit) */ {
 public:
  inline RiceDeltaEncoded64Bit() : RiceDeltaEncoded64Bit(nullptr) {}
  ~RiceDeltaEncoded64Bit() override;
  explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded64Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RiceDeltaEncoded64Bit& operator=(const RiceDeltaEncoded64Bit& from) {
    CopyFrom(from);
    return *this;
  }
  inline RiceDeltaEncoded64Bit& operator=(RiceDeltaEncoded64Bit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(RiceDeltaEncoded64Bit& a, RiceDeltaEncoded64Bit& b) {
    a.Swap(&b);
  }
  inline void Swap(RiceDeltaEncoded64Bit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RiceDeltaEncoded64Bit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RiceDeltaEncoded64Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RiceDeltaEncoded64Bit>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RiceDeltaEncoded64Bit& from);
  void MergeFrom(const RiceDeltaEncoded64Bit& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RiceDeltaEncoded64Bit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit";
  }
  protected:
  explicit RiceDeltaEncoded64Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kEncodedDataFieldNumber = 4,
    kFirstValueFieldNumber = 1,
    kRiceParameterFieldNumber = 2,
    kEntriesCountFieldNumber = 3,
  };
  // bytes encoded_data = 4;
  void clear_encoded_data();
  const std::string& encoded_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encoded_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encoded_data();
  PROTOBUF_NODISCARD std::string* release_encoded_data();
  void set_allocated_encoded_data(std::string* encoded_data);
  private:
  const std::string& _internal_encoded_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
  std::string* _internal_mutable_encoded_data();
  public:

  // uint64 first_value = 1;
  void clear_first_value();
  uint64_t first_value() const;
  void set_first_value(uint64_t value);
  private:
  uint64_t _internal_first_value() const;
  void _internal_set_first_value(uint64_t value);
  public:

  // int32 rice_parameter = 2;
  void clear_rice_parameter();
  int32_t rice_parameter() const;
  void set_rice_parameter(int32_t value);
  private:
  int32_t _internal_rice_parameter() const;
  void _internal_set_rice_parameter(int32_t value);
  public:

  // int32 entries_count = 3;
  void clear_entries_count();
  int32_t entries_count() const;
  void set_entries_count(int32_t value);
  private:
  int32_t _internal_entries_count() const;
  void _internal_set_entries_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
    uint64_t first_value_;
    int32_t rice_parameter_;
    int32_t entries_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class RiceDeltaEncoded128Bit final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit) */ {
 public:
  inline RiceDeltaEncoded128Bit() : RiceDeltaEncoded128Bit(nullptr) {}
  ~RiceDeltaEncoded128Bit() override;
  explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded128Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RiceDeltaEncoded128Bit& operator=(const RiceDeltaEncoded128Bit& from) {
    CopyFrom(from);
    return *this;
  }
  inline RiceDeltaEncoded128Bit& operator=(RiceDeltaEncoded128Bit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RiceDeltaEncoded128Bit& default_instance() {
    return *internal_default_instance();
  }
  static inline const RiceDeltaEncoded128Bit* internal_default_instance() {
    return reinterpret_cast<const RiceDeltaEncoded128Bit*>(
               &_RiceDeltaEncoded128Bit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(RiceDeltaEncoded128Bit& a, RiceDeltaEncoded128Bit& b) {
    a.Swap(&b);
  }
  inline void Swap(RiceDeltaEncoded128Bit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RiceDeltaEncoded128Bit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RiceDeltaEncoded128Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RiceDeltaEncoded128Bit>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RiceDeltaEncoded128Bit& from);
  void MergeFrom(const RiceDeltaEncoded128Bit& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RiceDeltaEncoded128Bit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit";
  }
  protected:
  explicit RiceDeltaEncoded128Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kEncodedDataFieldNumber = 5,
    kFirstValueHiFieldNumber = 1,
    kFirstValueLoFieldNumber = 2,
    kRiceParameterFieldNumber = 3,
    kEntriesCountFieldNumber = 4,
  };
  // bytes encoded_data = 5;
  void clear_encoded_data();
  const std::string& encoded_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encoded_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encoded_data();
  PROTOBUF_NODISCARD std::string* release_encoded_data();
  void set_allocated_encoded_data(std::string* encoded_data);
  private:
  const std::string& _internal_encoded_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
  std::string* _internal_mutable_encoded_data();
  public:

  // uint64 first_value_hi = 1;
  void clear_first_value_hi();
  uint64_t first_value_hi() const;
  void set_first_value_hi(uint64_t value);
  private:
  uint64_t _internal_first_value_hi() const;
  void _internal_set_first_value_hi(uint64_t value);
  public:

  // fixed64 first_value_lo = 2;
  void clear_first_value_lo();
  uint64_t first_value_lo() const;
  void set_first_value_lo(uint64_t value);
  private:
  uint64_t _internal_first_value_lo() const;
  void _internal_set_first_value_lo(uint64_t value);
  public:

  // int32 rice_parameter = 3;
  void clear_rice_parameter();
  int32_t rice_parameter() const;
  void set_rice_parameter(int32_t value);
  private:
  int32_t _internal_rice_parameter() const;
  void _internal_set_rice_parameter(int32_t value);
  public:

  // int32 entries_count = 4;
  void clear_entries_count();
  int32_t entries_count() const;
  void set_entries_count(int32_t value);
  private:
  int32_t _internal_entries_count() const;
  void _internal_set_entries_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
    uint64_t first_value_hi_;
    uint64_t first_value_lo_;
    int32_t rice_parameter_;
    int32_t entries_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class RiceDeltaEncoded256Bit final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit) */ {
 public:
  inline RiceDeltaEncoded256Bit() : RiceDeltaEncoded256Bit(nullptr) {}
  ~RiceDeltaEncoded256Bit() override;
  explicit PROTOBUF_CONSTEXPR RiceDeltaEncoded256Bit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RiceDeltaEncoded256Bit& operator=(const RiceDeltaEncoded256Bit& from) {
    CopyFrom(from);
    return *this;
  }
  inline RiceDeltaEncoded256Bit& operator=(RiceDeltaEncoded256Bit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RiceDeltaEncoded256Bit& default_instance() {
    return *internal_default_instance();
  }
  static inline const RiceDeltaEncoded256Bit* internal_default_instance() {
    return reinterpret_cast<const RiceDeltaEncoded256Bit*>(
               &_RiceDeltaEncoded256Bit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(RiceDeltaEncoded256Bit& a, RiceDeltaEncoded256Bit& b) {
    a.Swap(&b);
  }
  inline void Swap(RiceDeltaEncoded256Bit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RiceDeltaEncoded256Bit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RiceDeltaEncoded256Bit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RiceDeltaEncoded256Bit>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RiceDeltaEncoded256Bit& from);
  void MergeFrom(const RiceDeltaEncoded256Bit& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RiceDeltaEncoded256Bit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit";
  }
  protected:
  explicit RiceDeltaEncoded256Bit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kEncodedDataFieldNumber = 7,
    kFirstValueFirstPartFieldNumber = 1,
    kFirstValueSecondPartFieldNumber = 2,
    kFirstValueThirdPartFieldNumber = 3,
    kFirstValueFourthPartFieldNumber = 4,
    kRiceParameterFieldNumber = 5,
    kEntriesCountFieldNumber = 6,
  };
  // bytes encoded_data = 7;
  void clear_encoded_data();
  const std::string& encoded_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encoded_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encoded_data();
  PROTOBUF_NODISCARD std::string* release_encoded_data();
  void set_allocated_encoded_data(std::string* encoded_data);
  private:
  const std::string& _internal_encoded_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_data(const std::string& value);
  std::string* _internal_mutable_encoded_data();
  public:

  // uint64 first_value_first_part = 1;
  void clear_first_value_first_part();
  uint64_t first_value_first_part() const;
  void set_first_value_first_part(uint64_t value);
  private:
  uint64_t _internal_first_value_first_part() const;
  void _internal_set_first_value_first_part(uint64_t value);
  public:

  // fixed64 first_value_second_part = 2;
  void clear_first_value_second_part();
  uint64_t first_value_second_part() const;
  void set_first_value_second_part(uint64_t value);
  private:
  uint64_t _internal_first_value_second_part() const;
  void _internal_set_first_value_second_part(uint64_t value);
  public:

  // fixed64 first_value_third_part = 3;
  void clear_first_value_third_part();
  uint64_t first_value_third_part() const;
  void set_first_value_third_part(uint64_t value);
  private:
  uint64_t _internal_first_value_third_part() const;
  void _internal_set_first_value_third_part(uint64_t value);
  public:

  // fixed64 first_value_fourth_part = 4;
  void clear_first_value_fourth_part();
  uint64_t first_value_fourth_part() const;
  void set_first_value_fourth_part(uint64_t value);
  private:
  uint64_t _internal_first_value_fourth_part() const;
  void _internal_set_first_value_fourth_part(uint64_t value);
  public:

  // int32 rice_parameter = 5;
  void clear_rice_parameter();
  int32_t rice_parameter() const;
  void set_rice_parameter(int32_t value);
  private:
  int32_t _internal_rice_parameter() const;
  void _internal_set_rice_parameter(int32_t value);
  public:

  // int32 entries_count = 6;
  void clear_entries_count();
  int32_t entries_count() const;
  void set_entries_count(int32_t value);
  private:
  int32_t _internal_entries_count() const;
  void _internal_set_entries_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
    uint64_t first_value_first_part_;
    uint64_t first_value_second_part_;
    uint64_t first_value_third_part_;
    uint64_t first_value_fourth_part_;
    int32_t rice_parameter_;
    int32_t entries_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class HashListMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.HashListMetadata) */ {
 public:
  inline HashListMetadata() : HashListMetadata(nullptr) {}
  ~HashListMetadata() override;
  explicit PROTOBUF_CONSTEXPR HashListMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HashListMetadata& operator=(const HashListMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline HashListMetadata& operator=(HashListMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const HashListMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const HashListMetadata* internal_default_instance() {
    return reinterpret_cast<const HashListMetadata*>(
               &_HashListMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(HashListMetadata& a, HashListMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(HashListMetadata* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HashListMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HashListMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HashListMetadata>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const HashListMetadata& from);
  void MergeFrom(const HashListMetadata& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(HashListMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.HashListMetadata";
  }
  protected:
  explicit HashListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef HashListMetadata_HashLength HashLength;
  static constexpr HashLength HASH_LENGTH_UNSPECIFIED =
    HashListMetadata_HashLength_HASH_LENGTH_UNSPECIFIED;
  static constexpr HashLength FOUR_BYTES =
    HashListMetadata_HashLength_FOUR_BYTES;
  static constexpr HashLength EIGHT_BYTES =
    HashListMetadata_HashLength_EIGHT_BYTES;
  static constexpr HashLength SIXTEEN_BYTES =
    HashListMetadata_HashLength_SIXTEEN_BYTES;
  static constexpr HashLength THIRTY_TWO_BYTES =
    HashListMetadata_HashLength_THIRTY_TWO_BYTES;
  static inline bool HashLength_IsValid(int value) {
    return HashListMetadata_HashLength_IsValid(value);
  }
  static constexpr HashLength HashLength_MIN =
    HashListMetadata_HashLength_HashLength_MIN;
  static constexpr HashLength HashLength_MAX =
    HashListMetadata_HashLength_HashLength_MAX;
  static constexpr int HashLength_ARRAYSIZE =
    HashListMetadata_HashLength_HashLength_ARRAYSIZE;
  template<typename T>
  static inline const std::string& HashLength_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HashLength>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HashLength_Name.");
    return HashListMetadata_HashLength_Name(enum_t_value);
  }
  static inline bool HashLength_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HashLength* value) {
    return HashListMetadata_HashLength_Parse(name, value);
  }

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

  enum : int {
    kThreatTypesFieldNumber = 1,
    kLikelySafeTypesFieldNumber = 2,
    kDescriptionFieldNumber = 4,
    kHashLengthFieldNumber = 6,
  };
  // repeated .mozilla.safebrowsing.v5.ThreatType threat_types = 1;
  int threat_types_size() const;
  private:
  int _internal_threat_types_size() const;
  public:
  void clear_threat_types();
  private:
  ::mozilla::safebrowsing::v5::ThreatType _internal_threat_types(int index) const;
  void _internal_add_threat_types(::mozilla::safebrowsing::v5::ThreatType value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_types();
  public:
  ::mozilla::safebrowsing::v5::ThreatType threat_types(int index) const;
  void set_threat_types(int index, ::mozilla::safebrowsing::v5::ThreatType value);
  void add_threat_types(::mozilla::safebrowsing::v5::ThreatType value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_types() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_types();

  // repeated .mozilla.safebrowsing.v5.LikelySafeType likely_safe_types = 2;
  int likely_safe_types_size() const;
  private:
  int _internal_likely_safe_types_size() const;
  public:
  void clear_likely_safe_types();
  private:
  ::mozilla::safebrowsing::v5::LikelySafeType _internal_likely_safe_types(int index) const;
  void _internal_add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_likely_safe_types();
  public:
  ::mozilla::safebrowsing::v5::LikelySafeType likely_safe_types(int index) const;
  void set_likely_safe_types(int index, ::mozilla::safebrowsing::v5::LikelySafeType value);
  void add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& likely_safe_types() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_likely_safe_types();

  // string description = 4;
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // .mozilla.safebrowsing.v5.HashListMetadata.HashLength hash_length = 6;
  void clear_hash_length();
  ::mozilla::safebrowsing::v5::HashListMetadata_HashLength hash_length() const;
  void set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value);
  private:
  ::mozilla::safebrowsing::v5::HashListMetadata_HashLength _internal_hash_length() const;
  void _internal_set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.HashListMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_types_;
    mutable std::atomic<int> _threat_types_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> likely_safe_types_;
    mutable std::atomic<int> _likely_safe_types_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    int hash_length_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class HashList final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.HashList) */ {
 public:
  inline HashList() : HashList(nullptr) {}
  ~HashList() override;
  explicit PROTOBUF_CONSTEXPR HashList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HashList& operator=(const HashList& from) {
    CopyFrom(from);
    return *this;
  }
  inline HashList& operator=(HashList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const HashList& default_instance() {
    return *internal_default_instance();
  }
  enum CompressedAdditionsCase {
    kAdditionsFourBytes = 4,
    kAdditionsEightBytes = 9,
    kAdditionsSixteenBytes = 10,
    kAdditionsThirtyTwoBytes = 11,
    COMPRESSED_ADDITIONS_NOT_SET = 0,
  };

  static inline const HashList* internal_default_instance() {
    return reinterpret_cast<const HashList*>(
               &_HashList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(HashList& a, HashList& b) {
    a.Swap(&b);
  }
  inline void Swap(HashList* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HashList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HashList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HashList>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const HashList& from);
  void MergeFrom(const HashList& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(HashList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.HashList";
  }
  protected:
  explicit HashList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
    kVersionFieldNumber = 2,
    kSha256ChecksumFieldNumber = 7,
    kCompressedRemovalsFieldNumber = 5,
    kMinimumWaitDurationFieldNumber = 6,
    kMetadataFieldNumber = 8,
    kPartialUpdateFieldNumber = 3,
    kAdditionsFourBytesFieldNumber = 4,
    kAdditionsEightBytesFieldNumber = 9,
    kAdditionsSixteenBytesFieldNumber = 10,
    kAdditionsThirtyTwoBytesFieldNumber = 11,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bytes version = 2;
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // bytes sha256_checksum = 7;
  void clear_sha256_checksum();
  const std::string& sha256_checksum() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sha256_checksum(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sha256_checksum();
  PROTOBUF_NODISCARD std::string* release_sha256_checksum();
  void set_allocated_sha256_checksum(std::string* sha256_checksum);
  private:
  const std::string& _internal_sha256_checksum() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sha256_checksum(const std::string& value);
  std::string* _internal_mutable_sha256_checksum();
  public:

  // .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit compressed_removals = 5;
  bool has_compressed_removals() const;
  private:
  bool _internal_has_compressed_removals() const;
  public:
  void clear_compressed_removals();
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& compressed_removals() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* release_compressed_removals();
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* mutable_compressed_removals();
  void set_allocated_compressed_removals(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals);
  private:
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& _internal_compressed_removals() const;
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _internal_mutable_compressed_removals();
  public:
  void unsafe_arena_set_allocated_compressed_removals(
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals);
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* unsafe_arena_release_compressed_removals();

  // .mozilla.safebrowsing.v5.Duration minimum_wait_duration = 6;
  bool has_minimum_wait_duration() const;
  private:
  bool _internal_has_minimum_wait_duration() const;
  public:
  void clear_minimum_wait_duration();
  const ::mozilla::safebrowsing::v5::Duration& minimum_wait_duration() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::Duration* release_minimum_wait_duration();
  ::mozilla::safebrowsing::v5::Duration* mutable_minimum_wait_duration();
  void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::v5::Duration* minimum_wait_duration);
  private:
  const ::mozilla::safebrowsing::v5::Duration& _internal_minimum_wait_duration() const;
  ::mozilla::safebrowsing::v5::Duration* _internal_mutable_minimum_wait_duration();
  public:
  void unsafe_arena_set_allocated_minimum_wait_duration(
      ::mozilla::safebrowsing::v5::Duration* minimum_wait_duration);
  ::mozilla::safebrowsing::v5::Duration* unsafe_arena_release_minimum_wait_duration();

  // .mozilla.safebrowsing.v5.HashListMetadata metadata = 8;
  bool has_metadata() const;
  private:
  bool _internal_has_metadata() const;
  public:
  void clear_metadata();
  const ::mozilla::safebrowsing::v5::HashListMetadata& metadata() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::HashListMetadata* release_metadata();
  ::mozilla::safebrowsing::v5::HashListMetadata* mutable_metadata();
  void set_allocated_metadata(::mozilla::safebrowsing::v5::HashListMetadata* metadata);
  private:
  const ::mozilla::safebrowsing::v5::HashListMetadata& _internal_metadata() const;
  ::mozilla::safebrowsing::v5::HashListMetadata* _internal_mutable_metadata();
  public:
  void unsafe_arena_set_allocated_metadata(
      ::mozilla::safebrowsing::v5::HashListMetadata* metadata);
  ::mozilla::safebrowsing::v5::HashListMetadata* unsafe_arena_release_metadata();

  // bool partial_update = 3;
  void clear_partial_update();
  bool partial_update() const;
  void set_partial_update(bool value);
  private:
  bool _internal_partial_update() const;
  void _internal_set_partial_update(bool value);
  public:

  // .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit additions_four_bytes = 4;
  bool has_additions_four_bytes() const;
  private:
  bool _internal_has_additions_four_bytes() const;
  public:
  void clear_additions_four_bytes();
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& additions_four_bytes() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* release_additions_four_bytes();
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* mutable_additions_four_bytes();
  void set_allocated_additions_four_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes);
  private:
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& _internal_additions_four_bytes() const;
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _internal_mutable_additions_four_bytes();
  public:
  void unsafe_arena_set_allocated_additions_four_bytes(
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes);
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* unsafe_arena_release_additions_four_bytes();

  // .mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit additions_eight_bytes = 9;
  bool has_additions_eight_bytes() const;
  private:
  bool _internal_has_additions_eight_bytes() const;
  public:
  void clear_additions_eight_bytes();
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& additions_eight_bytes() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* release_additions_eight_bytes();
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* mutable_additions_eight_bytes();
  void set_allocated_additions_eight_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes);
  private:
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& _internal_additions_eight_bytes() const;
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* _internal_mutable_additions_eight_bytes();
  public:
  void unsafe_arena_set_allocated_additions_eight_bytes(
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes);
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* unsafe_arena_release_additions_eight_bytes();

  // .mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit additions_sixteen_bytes = 10;
  bool has_additions_sixteen_bytes() const;
  private:
  bool _internal_has_additions_sixteen_bytes() const;
  public:
  void clear_additions_sixteen_bytes();
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& additions_sixteen_bytes() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* release_additions_sixteen_bytes();
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* mutable_additions_sixteen_bytes();
  void set_allocated_additions_sixteen_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes);
  private:
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& _internal_additions_sixteen_bytes() const;
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* _internal_mutable_additions_sixteen_bytes();
  public:
  void unsafe_arena_set_allocated_additions_sixteen_bytes(
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes);
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* unsafe_arena_release_additions_sixteen_bytes();

  // .mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit additions_thirty_two_bytes = 11;
  bool has_additions_thirty_two_bytes() const;
  private:
  bool _internal_has_additions_thirty_two_bytes() const;
  public:
  void clear_additions_thirty_two_bytes();
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& additions_thirty_two_bytes() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* release_additions_thirty_two_bytes();
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* mutable_additions_thirty_two_bytes();
  void set_allocated_additions_thirty_two_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes);
  private:
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& _internal_additions_thirty_two_bytes() const;
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* _internal_mutable_additions_thirty_two_bytes();
  public:
  void unsafe_arena_set_allocated_additions_thirty_two_bytes(
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes);
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* unsafe_arena_release_additions_thirty_two_bytes();

  void clear_compressed_additions();
  CompressedAdditionsCase compressed_additions_case() const;
  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.HashList)
 private:
  class _Internal;
  void set_has_additions_four_bytes();
  void set_has_additions_eight_bytes();
  void set_has_additions_sixteen_bytes();
  void set_has_additions_thirty_two_bytes();

  inline bool has_compressed_additions() const;
  inline void clear_has_compressed_additions();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha256_checksum_;
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals_;
    ::mozilla::safebrowsing::v5::Duration* minimum_wait_duration_;
    ::mozilla::safebrowsing::v5::HashListMetadata* metadata_;
    bool partial_update_;
    union CompressedAdditionsUnion {
      constexpr CompressedAdditionsUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes_;
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes_;
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes_;
      ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes_;
    } compressed_additions_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class BatchGetHashListsRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.BatchGetHashListsRequest) */ {
 public:
  inline BatchGetHashListsRequest() : BatchGetHashListsRequest(nullptr) {}
  ~BatchGetHashListsRequest() override;
  explicit PROTOBUF_CONSTEXPR BatchGetHashListsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BatchGetHashListsRequest& operator=(const BatchGetHashListsRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline BatchGetHashListsRequest& operator=(BatchGetHashListsRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const BatchGetHashListsRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const BatchGetHashListsRequest* internal_default_instance() {
    return reinterpret_cast<const BatchGetHashListsRequest*>(
               &_BatchGetHashListsRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(BatchGetHashListsRequest& a, BatchGetHashListsRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(BatchGetHashListsRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BatchGetHashListsRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BatchGetHashListsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BatchGetHashListsRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const BatchGetHashListsRequest& from);
  void MergeFrom(const BatchGetHashListsRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BatchGetHashListsRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.BatchGetHashListsRequest";
  }
  protected:
  explicit BatchGetHashListsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNamesFieldNumber = 1,
    kVersionFieldNumber = 2,
    kSizeConstraintsFieldNumber = 4,
  };
  // repeated string names = 1;
  int names_size() const;
  private:
  int _internal_names_size() const;
  public:
  void clear_names();
  const std::string& names(int index) const;
  std::string* mutable_names(int index);
  void set_names(int index, const std::string& value);
  void set_names(int index, std::string&& value);
  void set_names(int index, const char* value);
  void set_names(int index, const char* value, size_t size);
  std::string* add_names();
  void add_names(const std::string& value);
  void add_names(std::string&& value);
  void add_names(const char* value);
  void add_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
  private:
  const std::string& _internal_names(int index) const;
  std::string* _internal_add_names();
  public:

  // repeated bytes version = 2;
  int version_size() const;
  private:
  int _internal_version_size() const;
  public:
  void clear_version();
  const std::string& version(int index) const;
  std::string* mutable_version(int index);
  void set_version(int index, const std::string& value);
  void set_version(int index, std::string&& value);
  void set_version(int index, const char* value);
  void set_version(int index, const void* value, size_t size);
  std::string* add_version();
  void add_version(const std::string& value);
  void add_version(std::string&& value);
  void add_version(const char* value);
  void add_version(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& version() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_version();
  private:
  const std::string& _internal_version(int index) const;
  std::string* _internal_add_version();
  public:

  // .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
  bool has_size_constraints() const;
  private:
  bool _internal_has_size_constraints() const;
  public:
  void clear_size_constraints();
  const ::mozilla::safebrowsing::v5::SizeConstraints& size_constraints() const;
  PROTOBUF_NODISCARD ::mozilla::safebrowsing::v5::SizeConstraints* release_size_constraints();
  ::mozilla::safebrowsing::v5::SizeConstraints* mutable_size_constraints();
  void set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
  private:
  const ::mozilla::safebrowsing::v5::SizeConstraints& _internal_size_constraints() const;
  ::mozilla::safebrowsing::v5::SizeConstraints* _internal_mutable_size_constraints();
  public:
  void unsafe_arena_set_allocated_size_constraints(
      ::mozilla::safebrowsing::v5::SizeConstraints* size_constraints);
  ::mozilla::safebrowsing::v5::SizeConstraints* unsafe_arena_release_size_constraints();

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.BatchGetHashListsRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> version_;
    ::mozilla::safebrowsing::v5::SizeConstraints* size_constraints_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class BatchGetHashListsResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.BatchGetHashListsResponse) */ {
 public:
  inline BatchGetHashListsResponse() : BatchGetHashListsResponse(nullptr) {}
  ~BatchGetHashListsResponse() override;
  explicit PROTOBUF_CONSTEXPR BatchGetHashListsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BatchGetHashListsResponse& operator=(const BatchGetHashListsResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline BatchGetHashListsResponse& operator=(BatchGetHashListsResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const BatchGetHashListsResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const BatchGetHashListsResponse* internal_default_instance() {
    return reinterpret_cast<const BatchGetHashListsResponse*>(
               &_BatchGetHashListsResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(BatchGetHashListsResponse& a, BatchGetHashListsResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(BatchGetHashListsResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BatchGetHashListsResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BatchGetHashListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BatchGetHashListsResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const BatchGetHashListsResponse& from);
  void MergeFrom(const BatchGetHashListsResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BatchGetHashListsResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.BatchGetHashListsResponse";
  }
  protected:
  explicit BatchGetHashListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kHashListsFieldNumber = 1,
  };
  // repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
  int hash_lists_size() const;
  private:
  int _internal_hash_lists_size() const;
  public:
  void clear_hash_lists();
  ::mozilla::safebrowsing::v5::HashList* mutable_hash_lists(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
      mutable_hash_lists();
  private:
  const ::mozilla::safebrowsing::v5::HashList& _internal_hash_lists(int index) const;
  ::mozilla::safebrowsing::v5::HashList* _internal_add_hash_lists();
  public:
  const ::mozilla::safebrowsing::v5::HashList& hash_lists(int index) const;
  ::mozilla::safebrowsing::v5::HashList* add_hash_lists();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
      hash_lists() const;

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.BatchGetHashListsResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList > hash_lists_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class ListHashListsRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.ListHashListsRequest) */ {
 public:
  inline ListHashListsRequest() : ListHashListsRequest(nullptr) {}
  ~ListHashListsRequest() override;
  explicit PROTOBUF_CONSTEXPR ListHashListsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ListHashListsRequest& operator=(const ListHashListsRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline ListHashListsRequest& operator=(ListHashListsRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(ListHashListsRequest& a, ListHashListsRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(ListHashListsRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ListHashListsRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ListHashListsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ListHashListsRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ListHashListsRequest& from);
  void MergeFrom(const ListHashListsRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ListHashListsRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.ListHashListsRequest";
  }
  protected:
  explicit ListHashListsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kPageTokenFieldNumber = 2,
    kPageSizeFieldNumber = 1,
  };
  // string page_token = 2;
  void clear_page_token();
  const std::string& page_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_page_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_page_token();
  PROTOBUF_NODISCARD std::string* release_page_token();
  void set_allocated_page_token(std::string* page_token);
  private:
  const std::string& _internal_page_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_token(const std::string& value);
  std::string* _internal_mutable_page_token();
  public:

  // int32 page_size = 1;
  void clear_page_size();
  int32_t page_size() const;
  void set_page_size(int32_t value);
  private:
  int32_t _internal_page_size() const;
  void _internal_set_page_size(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.ListHashListsRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr page_token_;
    int32_t page_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// -------------------------------------------------------------------

class ListHashListsResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.v5.ListHashListsResponse) */ {
 public:
  inline ListHashListsResponse() : ListHashListsResponse(nullptr) {}
  ~ListHashListsResponse() override;
  explicit PROTOBUF_CONSTEXPR ListHashListsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ListHashListsResponse& operator=(const ListHashListsResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline ListHashListsResponse& operator=(ListHashListsResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ListHashListsResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const ListHashListsResponse* internal_default_instance() {
    return reinterpret_cast<const ListHashListsResponse*>(
               &_ListHashListsResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(ListHashListsResponse& a, ListHashListsResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(ListHashListsResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ListHashListsResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ListHashListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ListHashListsResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ListHashListsResponse& from);
  void MergeFrom(const ListHashListsResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ListHashListsResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mozilla.safebrowsing.v5.ListHashListsResponse";
  }
  protected:
  explicit ListHashListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kHashListsFieldNumber = 1,
    kNextPageTokenFieldNumber = 2,
  };
  // repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
  int hash_lists_size() const;
  private:
  int _internal_hash_lists_size() const;
  public:
  void clear_hash_lists();
  ::mozilla::safebrowsing::v5::HashList* mutable_hash_lists(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
      mutable_hash_lists();
  private:
  const ::mozilla::safebrowsing::v5::HashList& _internal_hash_lists(int index) const;
  ::mozilla::safebrowsing::v5::HashList* _internal_add_hash_lists();
  public:
  const ::mozilla::safebrowsing::v5::HashList& hash_lists(int index) const;
  ::mozilla::safebrowsing::v5::HashList* add_hash_lists();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
      hash_lists() const;

  // string next_page_token = 2;
  void clear_next_page_token();
  const std::string& next_page_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_next_page_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_next_page_token();
  PROTOBUF_NODISCARD std::string* release_next_page_token();
  void set_allocated_next_page_token(std::string* next_page_token);
  private:
  const std::string& _internal_next_page_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_page_token(const std::string& value);
  std::string* _internal_mutable_next_page_token();
  public:

  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.v5.ListHashListsResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList > hash_lists_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr next_page_token_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_safebrowsing_5fv5_2eproto;
};
// ===================================================================


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

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

// repeated bytes hash_prefixes = 1;
inline int SearchHashesRequest::_internal_hash_prefixes_size() const {
  return _impl_.hash_prefixes_.size();
}
inline int SearchHashesRequest::hash_prefixes_size() const {
  return _internal_hash_prefixes_size();
}
inline void SearchHashesRequest::clear_hash_prefixes() {
  _impl_.hash_prefixes_.Clear();
}
inline std::string* SearchHashesRequest::add_hash_prefixes() {
  std::string* _s = _internal_add_hash_prefixes();
  // @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
  return _s;
}
inline const std::string& SearchHashesRequest::_internal_hash_prefixes(int index) const {
  return _impl_.hash_prefixes_.Get(index);
}
inline const std::string& SearchHashesRequest::hash_prefixes(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
  return _internal_hash_prefixes(index);
}
inline std::string* SearchHashesRequest::mutable_hash_prefixes(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
  return _impl_.hash_prefixes_.Mutable(index);
}
inline void SearchHashesRequest::set_hash_prefixes(int index, const std::string& value) {
  _impl_.hash_prefixes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::set_hash_prefixes(int index, std::string&& value) {
  _impl_.hash_prefixes_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::set_hash_prefixes(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.hash_prefixes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::set_hash_prefixes(int index, const void* value, size_t size) {
  _impl_.hash_prefixes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline std::string* SearchHashesRequest::_internal_add_hash_prefixes() {
  return _impl_.hash_prefixes_.Add();
}
inline void SearchHashesRequest::add_hash_prefixes(const std::string& value) {
  _impl_.hash_prefixes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::add_hash_prefixes(std::string&& value) {
  _impl_.hash_prefixes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::add_hash_prefixes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.hash_prefixes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline void SearchHashesRequest::add_hash_prefixes(const void* value, size_t size) {
  _impl_.hash_prefixes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchHashesRequest::hash_prefixes() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
  return _impl_.hash_prefixes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchHashesRequest::mutable_hash_prefixes() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.SearchHashesRequest.hash_prefixes)
  return &_impl_.hash_prefixes_;
}

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

// Duration

// int64 seconds = 1;
inline void Duration::clear_seconds() {
  _impl_.seconds_ = int64_t{0};
}
inline int64_t Duration::_internal_seconds() const {
  return _impl_.seconds_;
}
inline int64_t Duration::seconds() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.Duration.seconds)
  return _internal_seconds();
}
inline void Duration::_internal_set_seconds(int64_t value) {
  
  _impl_.seconds_ = value;
}
inline void Duration::set_seconds(int64_t value) {
  _internal_set_seconds(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.Duration.seconds)
}

// int32 nanos = 2;
inline void Duration::clear_nanos() {
  _impl_.nanos_ = 0;
}
inline int32_t Duration::_internal_nanos() const {
  return _impl_.nanos_;
}
inline int32_t Duration::nanos() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.Duration.nanos)
  return _internal_nanos();
}
inline void Duration::_internal_set_nanos(int32_t value) {
  
  _impl_.nanos_ = value;
}
inline void Duration::set_nanos(int32_t value) {
  _internal_set_nanos(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.Duration.nanos)
}

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

// SearchHashesResponse

// repeated .mozilla.safebrowsing.v5.FullHash full_hashes = 1;
inline int SearchHashesResponse::_internal_full_hashes_size() const {
  return _impl_.full_hashes_.size();
}
inline int SearchHashesResponse::full_hashes_size() const {
  return _internal_full_hashes_size();
}
inline void SearchHashesResponse::clear_full_hashes() {
  _impl_.full_hashes_.Clear();
}
inline ::mozilla::safebrowsing::v5::FullHash* SearchHashesResponse::mutable_full_hashes(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
  return _impl_.full_hashes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >*
SearchHashesResponse::mutable_full_hashes() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
  return &_impl_.full_hashes_;
}
inline const ::mozilla::safebrowsing::v5::FullHash& SearchHashesResponse::_internal_full_hashes(int index) const {
  return _impl_.full_hashes_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::FullHash& SearchHashesResponse::full_hashes(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
  return _internal_full_hashes(index);
}
inline ::mozilla::safebrowsing::v5::FullHash* SearchHashesResponse::_internal_add_full_hashes() {
  return _impl_.full_hashes_.Add();
}
inline ::mozilla::safebrowsing::v5::FullHash* SearchHashesResponse::add_full_hashes() {
  ::mozilla::safebrowsing::v5::FullHash* _add = _internal_add_full_hashes();
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash >&
SearchHashesResponse::full_hashes() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.SearchHashesResponse.full_hashes)
  return _impl_.full_hashes_;
}

// .mozilla.safebrowsing.v5.Duration cache_duration = 2;
inline bool SearchHashesResponse::_internal_has_cache_duration() const {
  return this != internal_default_instance() && _impl_.cache_duration_ != nullptr;
}
inline bool SearchHashesResponse::has_cache_duration() const {
  return _internal_has_cache_duration();
}
inline void SearchHashesResponse::clear_cache_duration() {
  if (GetArenaForAllocation() == nullptr && _impl_.cache_duration_ != nullptr) {
    delete _impl_.cache_duration_;
  }
  _impl_.cache_duration_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::Duration& SearchHashesResponse::_internal_cache_duration() const {
  const ::mozilla::safebrowsing::v5::Duration* p = _impl_.cache_duration_;
  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::Duration&>(
      ::mozilla::safebrowsing::v5::_Duration_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::Duration& SearchHashesResponse::cache_duration() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
  return _internal_cache_duration();
}
inline void SearchHashesResponse::unsafe_arena_set_allocated_cache_duration(
    ::mozilla::safebrowsing::v5::Duration* cache_duration) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cache_duration_);
  }
  _impl_.cache_duration_ = cache_duration;
  if (cache_duration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::release_cache_duration() {
  
  ::mozilla::safebrowsing::v5::Duration* temp = _impl_.cache_duration_;
  _impl_.cache_duration_ = 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 ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::unsafe_arena_release_cache_duration() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
  
  ::mozilla::safebrowsing::v5::Duration* temp = _impl_.cache_duration_;
  _impl_.cache_duration_ = nullptr;
  return temp;
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::_internal_mutable_cache_duration() {
  
  if (_impl_.cache_duration_ == nullptr) {
    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::Duration>(GetArenaForAllocation());
    _impl_.cache_duration_ = p;
  }
  return _impl_.cache_duration_;
}
inline ::mozilla::safebrowsing::v5::Duration* SearchHashesResponse::mutable_cache_duration() {
  ::mozilla::safebrowsing::v5::Duration* _msg = _internal_mutable_cache_duration();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
  return _msg;
}
inline void SearchHashesResponse::set_allocated_cache_duration(::mozilla::safebrowsing::v5::Duration* cache_duration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.cache_duration_;
  }
  if (cache_duration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cache_duration);
    if (message_arena != submessage_arena) {
      cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cache_duration, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.cache_duration_ = cache_duration;
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.SearchHashesResponse.cache_duration)
}

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

// FullHash_FullHashDetail

// .mozilla.safebrowsing.v5.ThreatType threat_type = 1;
inline void FullHash_FullHashDetail::clear_threat_type() {
  _impl_.threat_type_ = 0;
}
inline ::mozilla::safebrowsing::v5::ThreatType FullHash_FullHashDetail::_internal_threat_type() const {
  return static_cast< ::mozilla::safebrowsing::v5::ThreatType >(_impl_.threat_type_);
}
inline ::mozilla::safebrowsing::v5::ThreatType FullHash_FullHashDetail::threat_type() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.FullHashDetail.threat_type)
  return _internal_threat_type();
}
inline void FullHash_FullHashDetail::_internal_set_threat_type(::mozilla::safebrowsing::v5::ThreatType value) {
  
  _impl_.threat_type_ = value;
}
inline void FullHash_FullHashDetail::set_threat_type(::mozilla::safebrowsing::v5::ThreatType value) {
  _internal_set_threat_type(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.FullHash.FullHashDetail.threat_type)
}

// repeated .mozilla.safebrowsing.v5.ThreatAttribute attributes = 2;
inline int FullHash_FullHashDetail::_internal_attributes_size() const {
  return _impl_.attributes_.size();
}
inline int FullHash_FullHashDetail::attributes_size() const {
  return _internal_attributes_size();
}
inline void FullHash_FullHashDetail::clear_attributes() {
  _impl_.attributes_.Clear();
}
inline ::mozilla::safebrowsing::v5::ThreatAttribute FullHash_FullHashDetail::_internal_attributes(int index) const {
  return static_cast< ::mozilla::safebrowsing::v5::ThreatAttribute >(_impl_.attributes_.Get(index));
}
inline ::mozilla::safebrowsing::v5::ThreatAttribute FullHash_FullHashDetail::attributes(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
  return _internal_attributes(index);
}
inline void FullHash_FullHashDetail::set_attributes(int index, ::mozilla::safebrowsing::v5::ThreatAttribute value) {
  _impl_.attributes_.Set(index, value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
}
inline void FullHash_FullHashDetail::_internal_add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value) {
  _impl_.attributes_.Add(value);
}
inline void FullHash_FullHashDetail::add_attributes(::mozilla::safebrowsing::v5::ThreatAttribute value) {
  _internal_add_attributes(value);
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
FullHash_FullHashDetail::attributes() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
  return _impl_.attributes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
FullHash_FullHashDetail::_internal_mutable_attributes() {
  return &_impl_.attributes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
FullHash_FullHashDetail::mutable_attributes() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.FullHash.FullHashDetail.attributes)
  return _internal_mutable_attributes();
}

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

// FullHash

// bytes full_hash = 1;
inline void FullHash::clear_full_hash() {
  _impl_.full_hash_.ClearToEmpty();
}
inline const std::string& FullHash::full_hash() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.full_hash)
  return _internal_full_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FullHash::set_full_hash(ArgT0&& arg0, ArgT... args) {
 
 _impl_.full_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.FullHash.full_hash)
}
inline std::string* FullHash::mutable_full_hash() {
  std::string* _s = _internal_mutable_full_hash();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.FullHash.full_hash)
  return _s;
}
inline const std::string& FullHash::_internal_full_hash() const {
  return _impl_.full_hash_.Get();
}
inline void FullHash::_internal_set_full_hash(const std::string& value) {
  
  _impl_.full_hash_.Set(value, GetArenaForAllocation());
}
inline std::string* FullHash::_internal_mutable_full_hash() {
  
  return _impl_.full_hash_.Mutable(GetArenaForAllocation());
}
inline std::string* FullHash::release_full_hash() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.FullHash.full_hash)
  return _impl_.full_hash_.Release();
}
inline void FullHash::set_allocated_full_hash(std::string* full_hash) {
  if (full_hash != nullptr) {
    
  } else {
    
  }
  _impl_.full_hash_.SetAllocated(full_hash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.full_hash_.IsDefault()) {
    _impl_.full_hash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.FullHash.full_hash)
}

// repeated .mozilla.safebrowsing.v5.FullHash.FullHashDetail full_hash_details = 2;
inline int FullHash::_internal_full_hash_details_size() const {
  return _impl_.full_hash_details_.size();
}
inline int FullHash::full_hash_details_size() const {
  return _internal_full_hash_details_size();
}
inline void FullHash::clear_full_hash_details() {
  _impl_.full_hash_details_.Clear();
}
inline ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* FullHash::mutable_full_hash_details(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.FullHash.full_hash_details)
  return _impl_.full_hash_details_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >*
FullHash::mutable_full_hash_details() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.FullHash.full_hash_details)
  return &_impl_.full_hash_details_;
}
inline const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& FullHash::_internal_full_hash_details(int index) const {
  return _impl_.full_hash_details_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::FullHash_FullHashDetail& FullHash::full_hash_details(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.FullHash.full_hash_details)
  return _internal_full_hash_details(index);
}
inline ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* FullHash::_internal_add_full_hash_details() {
  return _impl_.full_hash_details_.Add();
}
inline ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* FullHash::add_full_hash_details() {
  ::mozilla::safebrowsing::v5::FullHash_FullHashDetail* _add = _internal_add_full_hash_details();
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.FullHash.full_hash_details)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::FullHash_FullHashDetail >&
FullHash::full_hash_details() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.FullHash.full_hash_details)
  return _impl_.full_hash_details_;
}

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

// GetHashListRequest

// string name = 1;
inline void GetHashListRequest::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& GetHashListRequest::name() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.GetHashListRequest.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GetHashListRequest::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.GetHashListRequest.name)
}
inline std::string* GetHashListRequest::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.GetHashListRequest.name)
  return _s;
}
inline const std::string& GetHashListRequest::_internal_name() const {
  return _impl_.name_.Get();
}
inline void GetHashListRequest::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* GetHashListRequest::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* GetHashListRequest::release_name() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.GetHashListRequest.name)
  return _impl_.name_.Release();
}
inline void GetHashListRequest::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.name)
}

// bytes version = 2;
inline void GetHashListRequest::clear_version() {
  _impl_.version_.ClearToEmpty();
}
inline const std::string& GetHashListRequest::version() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.GetHashListRequest.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GetHashListRequest::set_version(ArgT0&& arg0, ArgT... args) {
 
 _impl_.version_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.GetHashListRequest.version)
}
inline std::string* GetHashListRequest::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.GetHashListRequest.version)
  return _s;
}
inline const std::string& GetHashListRequest::_internal_version() const {
  return _impl_.version_.Get();
}
inline void GetHashListRequest::_internal_set_version(const std::string& value) {
  
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* GetHashListRequest::_internal_mutable_version() {
  
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* GetHashListRequest::release_version() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.GetHashListRequest.version)
  return _impl_.version_.Release();
}
inline void GetHashListRequest::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    
  } else {
    
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.version)
}

// .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
inline bool GetHashListRequest::_internal_has_size_constraints() const {
  return this != internal_default_instance() && _impl_.size_constraints_ != nullptr;
}
inline bool GetHashListRequest::has_size_constraints() const {
  return _internal_has_size_constraints();
}
inline void GetHashListRequest::clear_size_constraints() {
  if (GetArenaForAllocation() == nullptr && _impl_.size_constraints_ != nullptr) {
    delete _impl_.size_constraints_;
  }
  _impl_.size_constraints_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& GetHashListRequest::_internal_size_constraints() const {
  const ::mozilla::safebrowsing::v5::SizeConstraints* p = _impl_.size_constraints_;
  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::SizeConstraints&>(
      ::mozilla::safebrowsing::v5::_SizeConstraints_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& GetHashListRequest::size_constraints() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
  return _internal_size_constraints();
}
inline void GetHashListRequest::unsafe_arena_set_allocated_size_constraints(
    ::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.size_constraints_);
  }
  _impl_.size_constraints_ = size_constraints;
  if (size_constraints) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::release_size_constraints() {
  
  ::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
  _impl_.size_constraints_ = 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 ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::unsafe_arena_release_size_constraints() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
  
  ::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
  _impl_.size_constraints_ = nullptr;
  return temp;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::_internal_mutable_size_constraints() {
  
  if (_impl_.size_constraints_ == nullptr) {
    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::SizeConstraints>(GetArenaForAllocation());
    _impl_.size_constraints_ = p;
  }
  return _impl_.size_constraints_;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* GetHashListRequest::mutable_size_constraints() {
  ::mozilla::safebrowsing::v5::SizeConstraints* _msg = _internal_mutable_size_constraints();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
  return _msg;
}
inline void GetHashListRequest::set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.size_constraints_;
  }
  if (size_constraints) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(size_constraints);
    if (message_arena != submessage_arena) {
      size_constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, size_constraints, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.size_constraints_ = size_constraints;
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.GetHashListRequest.size_constraints)
}

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

// SizeConstraints

// int32 max_update_entries = 1;
inline void SizeConstraints::clear_max_update_entries() {
  _impl_.max_update_entries_ = 0;
}
inline int32_t SizeConstraints::_internal_max_update_entries() const {
  return _impl_.max_update_entries_;
}
inline int32_t SizeConstraints::max_update_entries() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SizeConstraints.max_update_entries)
  return _internal_max_update_entries();
}
inline void SizeConstraints::_internal_set_max_update_entries(int32_t value) {
  
  _impl_.max_update_entries_ = value;
}
inline void SizeConstraints::set_max_update_entries(int32_t value) {
  _internal_set_max_update_entries(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SizeConstraints.max_update_entries)
}

// int32 max_database_entries = 2;
inline void SizeConstraints::clear_max_database_entries() {
  _impl_.max_database_entries_ = 0;
}
inline int32_t SizeConstraints::_internal_max_database_entries() const {
  return _impl_.max_database_entries_;
}
inline int32_t SizeConstraints::max_database_entries() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.SizeConstraints.max_database_entries)
  return _internal_max_database_entries();
}
inline void SizeConstraints::_internal_set_max_database_entries(int32_t value) {
  
  _impl_.max_database_entries_ = value;
}
inline void SizeConstraints::set_max_database_entries(int32_t value) {
  _internal_set_max_database_entries(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.SizeConstraints.max_database_entries)
}

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

// RiceDeltaEncoded32Bit

// uint32 first_value = 1;
inline void RiceDeltaEncoded32Bit::clear_first_value() {
  _impl_.first_value_ = 0u;
}
inline uint32_t RiceDeltaEncoded32Bit::_internal_first_value() const {
  return _impl_.first_value_;
}
inline uint32_t RiceDeltaEncoded32Bit::first_value() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.first_value)
  return _internal_first_value();
}
inline void RiceDeltaEncoded32Bit::_internal_set_first_value(uint32_t value) {
  
  _impl_.first_value_ = value;
}
inline void RiceDeltaEncoded32Bit::set_first_value(uint32_t value) {
  _internal_set_first_value(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.first_value)
}

// int32 rice_parameter = 2;
inline void RiceDeltaEncoded32Bit::clear_rice_parameter() {
  _impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded32Bit::_internal_rice_parameter() const {
  return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded32Bit::rice_parameter() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.rice_parameter)
  return _internal_rice_parameter();
}
inline void RiceDeltaEncoded32Bit::_internal_set_rice_parameter(int32_t value) {
  
  _impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded32Bit::set_rice_parameter(int32_t value) {
  _internal_set_rice_parameter(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.rice_parameter)
}

// int32 entries_count = 3;
inline void RiceDeltaEncoded32Bit::clear_entries_count() {
  _impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded32Bit::_internal_entries_count() const {
  return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded32Bit::entries_count() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.entries_count)
  return _internal_entries_count();
}
inline void RiceDeltaEncoded32Bit::_internal_set_entries_count(int32_t value) {
  
  _impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded32Bit::set_entries_count(int32_t value) {
  _internal_set_entries_count(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.entries_count)
}

// bytes encoded_data = 4;
inline void RiceDeltaEncoded32Bit::clear_encoded_data() {
  _impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded32Bit::encoded_data() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
  return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded32Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
 
 _impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded32Bit::mutable_encoded_data() {
  std::string* _s = _internal_mutable_encoded_data();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
  return _s;
}
inline const std::string& RiceDeltaEncoded32Bit::_internal_encoded_data() const {
  return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded32Bit::_internal_set_encoded_data(const std::string& value) {
  
  _impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded32Bit::_internal_mutable_encoded_data() {
  
  return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded32Bit::release_encoded_data() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
  return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded32Bit::set_allocated_encoded_data(std::string* encoded_data) {
  if (encoded_data != nullptr) {
    
  } else {
    
  }
  _impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encoded_data_.IsDefault()) {
    _impl_.encoded_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit.encoded_data)
}

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

// RiceDeltaEncoded64Bit

// uint64 first_value = 1;
inline void RiceDeltaEncoded64Bit::clear_first_value() {
  _impl_.first_value_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded64Bit::_internal_first_value() const {
  return _impl_.first_value_;
}
inline uint64_t RiceDeltaEncoded64Bit::first_value() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.first_value)
  return _internal_first_value();
}
inline void RiceDeltaEncoded64Bit::_internal_set_first_value(uint64_t value) {
  
  _impl_.first_value_ = value;
}
inline void RiceDeltaEncoded64Bit::set_first_value(uint64_t value) {
  _internal_set_first_value(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.first_value)
}

// int32 rice_parameter = 2;
inline void RiceDeltaEncoded64Bit::clear_rice_parameter() {
  _impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded64Bit::_internal_rice_parameter() const {
  return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded64Bit::rice_parameter() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.rice_parameter)
  return _internal_rice_parameter();
}
inline void RiceDeltaEncoded64Bit::_internal_set_rice_parameter(int32_t value) {
  
  _impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded64Bit::set_rice_parameter(int32_t value) {
  _internal_set_rice_parameter(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.rice_parameter)
}

// int32 entries_count = 3;
inline void RiceDeltaEncoded64Bit::clear_entries_count() {
  _impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded64Bit::_internal_entries_count() const {
  return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded64Bit::entries_count() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.entries_count)
  return _internal_entries_count();
}
inline void RiceDeltaEncoded64Bit::_internal_set_entries_count(int32_t value) {
  
  _impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded64Bit::set_entries_count(int32_t value) {
  _internal_set_entries_count(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.entries_count)
}

// bytes encoded_data = 4;
inline void RiceDeltaEncoded64Bit::clear_encoded_data() {
  _impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded64Bit::encoded_data() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
  return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded64Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
 
 _impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded64Bit::mutable_encoded_data() {
  std::string* _s = _internal_mutable_encoded_data();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
  return _s;
}
inline const std::string& RiceDeltaEncoded64Bit::_internal_encoded_data() const {
  return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded64Bit::_internal_set_encoded_data(const std::string& value) {
  
  _impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded64Bit::_internal_mutable_encoded_data() {
  
  return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded64Bit::release_encoded_data() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
  return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded64Bit::set_allocated_encoded_data(std::string* encoded_data) {
  if (encoded_data != nullptr) {
    
  } else {
    
  }
  _impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encoded_data_.IsDefault()) {
    _impl_.encoded_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit.encoded_data)
}

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

// RiceDeltaEncoded128Bit

// uint64 first_value_hi = 1;
inline void RiceDeltaEncoded128Bit::clear_first_value_hi() {
  _impl_.first_value_hi_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded128Bit::_internal_first_value_hi() const {
  return _impl_.first_value_hi_;
}
inline uint64_t RiceDeltaEncoded128Bit::first_value_hi() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_hi)
  return _internal_first_value_hi();
}
inline void RiceDeltaEncoded128Bit::_internal_set_first_value_hi(uint64_t value) {
  
  _impl_.first_value_hi_ = value;
}
inline void RiceDeltaEncoded128Bit::set_first_value_hi(uint64_t value) {
  _internal_set_first_value_hi(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_hi)
}

// fixed64 first_value_lo = 2;
inline void RiceDeltaEncoded128Bit::clear_first_value_lo() {
  _impl_.first_value_lo_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded128Bit::_internal_first_value_lo() const {
  return _impl_.first_value_lo_;
}
inline uint64_t RiceDeltaEncoded128Bit::first_value_lo() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_lo)
  return _internal_first_value_lo();
}
inline void RiceDeltaEncoded128Bit::_internal_set_first_value_lo(uint64_t value) {
  
  _impl_.first_value_lo_ = value;
}
inline void RiceDeltaEncoded128Bit::set_first_value_lo(uint64_t value) {
  _internal_set_first_value_lo(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.first_value_lo)
}

// int32 rice_parameter = 3;
inline void RiceDeltaEncoded128Bit::clear_rice_parameter() {
  _impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded128Bit::_internal_rice_parameter() const {
  return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded128Bit::rice_parameter() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.rice_parameter)
  return _internal_rice_parameter();
}
inline void RiceDeltaEncoded128Bit::_internal_set_rice_parameter(int32_t value) {
  
  _impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded128Bit::set_rice_parameter(int32_t value) {
  _internal_set_rice_parameter(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.rice_parameter)
}

// int32 entries_count = 4;
inline void RiceDeltaEncoded128Bit::clear_entries_count() {
  _impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded128Bit::_internal_entries_count() const {
  return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded128Bit::entries_count() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.entries_count)
  return _internal_entries_count();
}
inline void RiceDeltaEncoded128Bit::_internal_set_entries_count(int32_t value) {
  
  _impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded128Bit::set_entries_count(int32_t value) {
  _internal_set_entries_count(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.entries_count)
}

// bytes encoded_data = 5;
inline void RiceDeltaEncoded128Bit::clear_encoded_data() {
  _impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded128Bit::encoded_data() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
  return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded128Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
 
 _impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded128Bit::mutable_encoded_data() {
  std::string* _s = _internal_mutable_encoded_data();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
  return _s;
}
inline const std::string& RiceDeltaEncoded128Bit::_internal_encoded_data() const {
  return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded128Bit::_internal_set_encoded_data(const std::string& value) {
  
  _impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded128Bit::_internal_mutable_encoded_data() {
  
  return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded128Bit::release_encoded_data() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
  return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded128Bit::set_allocated_encoded_data(std::string* encoded_data) {
  if (encoded_data != nullptr) {
    
  } else {
    
  }
  _impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encoded_data_.IsDefault()) {
    _impl_.encoded_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit.encoded_data)
}

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

// RiceDeltaEncoded256Bit

// uint64 first_value_first_part = 1;
inline void RiceDeltaEncoded256Bit::clear_first_value_first_part() {
  _impl_.first_value_first_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_first_part() const {
  return _impl_.first_value_first_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_first_part() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_first_part)
  return _internal_first_value_first_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_first_part(uint64_t value) {
  
  _impl_.first_value_first_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_first_part(uint64_t value) {
  _internal_set_first_value_first_part(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_first_part)
}

// fixed64 first_value_second_part = 2;
inline void RiceDeltaEncoded256Bit::clear_first_value_second_part() {
  _impl_.first_value_second_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_second_part() const {
  return _impl_.first_value_second_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_second_part() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_second_part)
  return _internal_first_value_second_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_second_part(uint64_t value) {
  
  _impl_.first_value_second_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_second_part(uint64_t value) {
  _internal_set_first_value_second_part(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_second_part)
}

// fixed64 first_value_third_part = 3;
inline void RiceDeltaEncoded256Bit::clear_first_value_third_part() {
  _impl_.first_value_third_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_third_part() const {
  return _impl_.first_value_third_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_third_part() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_third_part)
  return _internal_first_value_third_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_third_part(uint64_t value) {
  
  _impl_.first_value_third_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_third_part(uint64_t value) {
  _internal_set_first_value_third_part(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_third_part)
}

// fixed64 first_value_fourth_part = 4;
inline void RiceDeltaEncoded256Bit::clear_first_value_fourth_part() {
  _impl_.first_value_fourth_part_ = uint64_t{0u};
}
inline uint64_t RiceDeltaEncoded256Bit::_internal_first_value_fourth_part() const {
  return _impl_.first_value_fourth_part_;
}
inline uint64_t RiceDeltaEncoded256Bit::first_value_fourth_part() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_fourth_part)
  return _internal_first_value_fourth_part();
}
inline void RiceDeltaEncoded256Bit::_internal_set_first_value_fourth_part(uint64_t value) {
  
  _impl_.first_value_fourth_part_ = value;
}
inline void RiceDeltaEncoded256Bit::set_first_value_fourth_part(uint64_t value) {
  _internal_set_first_value_fourth_part(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.first_value_fourth_part)
}

// int32 rice_parameter = 5;
inline void RiceDeltaEncoded256Bit::clear_rice_parameter() {
  _impl_.rice_parameter_ = 0;
}
inline int32_t RiceDeltaEncoded256Bit::_internal_rice_parameter() const {
  return _impl_.rice_parameter_;
}
inline int32_t RiceDeltaEncoded256Bit::rice_parameter() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.rice_parameter)
  return _internal_rice_parameter();
}
inline void RiceDeltaEncoded256Bit::_internal_set_rice_parameter(int32_t value) {
  
  _impl_.rice_parameter_ = value;
}
inline void RiceDeltaEncoded256Bit::set_rice_parameter(int32_t value) {
  _internal_set_rice_parameter(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.rice_parameter)
}

// int32 entries_count = 6;
inline void RiceDeltaEncoded256Bit::clear_entries_count() {
  _impl_.entries_count_ = 0;
}
inline int32_t RiceDeltaEncoded256Bit::_internal_entries_count() const {
  return _impl_.entries_count_;
}
inline int32_t RiceDeltaEncoded256Bit::entries_count() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.entries_count)
  return _internal_entries_count();
}
inline void RiceDeltaEncoded256Bit::_internal_set_entries_count(int32_t value) {
  
  _impl_.entries_count_ = value;
}
inline void RiceDeltaEncoded256Bit::set_entries_count(int32_t value) {
  _internal_set_entries_count(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.entries_count)
}

// bytes encoded_data = 7;
inline void RiceDeltaEncoded256Bit::clear_encoded_data() {
  _impl_.encoded_data_.ClearToEmpty();
}
inline const std::string& RiceDeltaEncoded256Bit::encoded_data() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
  return _internal_encoded_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RiceDeltaEncoded256Bit::set_encoded_data(ArgT0&& arg0, ArgT... args) {
 
 _impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
}
inline std::string* RiceDeltaEncoded256Bit::mutable_encoded_data() {
  std::string* _s = _internal_mutable_encoded_data();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
  return _s;
}
inline const std::string& RiceDeltaEncoded256Bit::_internal_encoded_data() const {
  return _impl_.encoded_data_.Get();
}
inline void RiceDeltaEncoded256Bit::_internal_set_encoded_data(const std::string& value) {
  
  _impl_.encoded_data_.Set(value, GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded256Bit::_internal_mutable_encoded_data() {
  
  return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
}
inline std::string* RiceDeltaEncoded256Bit::release_encoded_data() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
  return _impl_.encoded_data_.Release();
}
inline void RiceDeltaEncoded256Bit::set_allocated_encoded_data(std::string* encoded_data) {
  if (encoded_data != nullptr) {
    
  } else {
    
  }
  _impl_.encoded_data_.SetAllocated(encoded_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encoded_data_.IsDefault()) {
    _impl_.encoded_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit.encoded_data)
}

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

// HashListMetadata

// repeated .mozilla.safebrowsing.v5.ThreatType threat_types = 1;
inline int HashListMetadata::_internal_threat_types_size() const {
  return _impl_.threat_types_.size();
}
inline int HashListMetadata::threat_types_size() const {
  return _internal_threat_types_size();
}
inline void HashListMetadata::clear_threat_types() {
  _impl_.threat_types_.Clear();
}
inline ::mozilla::safebrowsing::v5::ThreatType HashListMetadata::_internal_threat_types(int index) const {
  return static_cast< ::mozilla::safebrowsing::v5::ThreatType >(_impl_.threat_types_.Get(index));
}
inline ::mozilla::safebrowsing::v5::ThreatType HashListMetadata::threat_types(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
  return _internal_threat_types(index);
}
inline void HashListMetadata::set_threat_types(int index, ::mozilla::safebrowsing::v5::ThreatType value) {
  _impl_.threat_types_.Set(index, value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
}
inline void HashListMetadata::_internal_add_threat_types(::mozilla::safebrowsing::v5::ThreatType value) {
  _impl_.threat_types_.Add(value);
}
inline void HashListMetadata::add_threat_types(::mozilla::safebrowsing::v5::ThreatType value) {
  _internal_add_threat_types(value);
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
HashListMetadata::threat_types() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
  return _impl_.threat_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::_internal_mutable_threat_types() {
  return &_impl_.threat_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::mutable_threat_types() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.HashListMetadata.threat_types)
  return _internal_mutable_threat_types();
}

// repeated .mozilla.safebrowsing.v5.LikelySafeType likely_safe_types = 2;
inline int HashListMetadata::_internal_likely_safe_types_size() const {
  return _impl_.likely_safe_types_.size();
}
inline int HashListMetadata::likely_safe_types_size() const {
  return _internal_likely_safe_types_size();
}
inline void HashListMetadata::clear_likely_safe_types() {
  _impl_.likely_safe_types_.Clear();
}
inline ::mozilla::safebrowsing::v5::LikelySafeType HashListMetadata::_internal_likely_safe_types(int index) const {
  return static_cast< ::mozilla::safebrowsing::v5::LikelySafeType >(_impl_.likely_safe_types_.Get(index));
}
inline ::mozilla::safebrowsing::v5::LikelySafeType HashListMetadata::likely_safe_types(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
  return _internal_likely_safe_types(index);
}
inline void HashListMetadata::set_likely_safe_types(int index, ::mozilla::safebrowsing::v5::LikelySafeType value) {
  _impl_.likely_safe_types_.Set(index, value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
}
inline void HashListMetadata::_internal_add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value) {
  _impl_.likely_safe_types_.Add(value);
}
inline void HashListMetadata::add_likely_safe_types(::mozilla::safebrowsing::v5::LikelySafeType value) {
  _internal_add_likely_safe_types(value);
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
HashListMetadata::likely_safe_types() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
  return _impl_.likely_safe_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::_internal_mutable_likely_safe_types() {
  return &_impl_.likely_safe_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
HashListMetadata::mutable_likely_safe_types() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.HashListMetadata.likely_safe_types)
  return _internal_mutable_likely_safe_types();
}

// string description = 4;
inline void HashListMetadata::clear_description() {
  _impl_.description_.ClearToEmpty();
}
inline const std::string& HashListMetadata::description() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashListMetadata::set_description(ArgT0&& arg0, ArgT... args) {
 
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.description)
}
inline std::string* HashListMetadata::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashListMetadata.description)
  return _s;
}
inline const std::string& HashListMetadata::_internal_description() const {
  return _impl_.description_.Get();
}
inline void HashListMetadata::_internal_set_description(const std::string& value) {
  
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* HashListMetadata::_internal_mutable_description() {
  
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* HashListMetadata::release_description() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashListMetadata.description)
  return _impl_.description_.Release();
}
inline void HashListMetadata::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashListMetadata.description)
}

// .mozilla.safebrowsing.v5.HashListMetadata.HashLength hash_length = 6;
inline void HashListMetadata::clear_hash_length() {
  _impl_.hash_length_ = 0;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata_HashLength HashListMetadata::_internal_hash_length() const {
  return static_cast< ::mozilla::safebrowsing::v5::HashListMetadata_HashLength >(_impl_.hash_length_);
}
inline ::mozilla::safebrowsing::v5::HashListMetadata_HashLength HashListMetadata::hash_length() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashListMetadata.hash_length)
  return _internal_hash_length();
}
inline void HashListMetadata::_internal_set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value) {
  
  _impl_.hash_length_ = value;
}
inline void HashListMetadata::set_hash_length(::mozilla::safebrowsing::v5::HashListMetadata_HashLength value) {
  _internal_set_hash_length(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashListMetadata.hash_length)
}

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

// HashList

// .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit additions_four_bytes = 4;
inline bool HashList::_internal_has_additions_four_bytes() const {
  return compressed_additions_case() == kAdditionsFourBytes;
}
inline bool HashList::has_additions_four_bytes() const {
  return _internal_has_additions_four_bytes();
}
inline void HashList::set_has_additions_four_bytes() {
  _impl_._oneof_case_[0] = kAdditionsFourBytes;
}
inline void HashList::clear_additions_four_bytes() {
  if (_internal_has_additions_four_bytes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.compressed_additions_.additions_four_bytes_;
    }
    clear_has_compressed_additions();
  }
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::release_additions_four_bytes() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
  if (_internal_has_additions_four_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_additions_.additions_four_bytes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.compressed_additions_.additions_four_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::_internal_additions_four_bytes() const {
  return _internal_has_additions_four_bytes()
      ? *_impl_.compressed_additions_.additions_four_bytes_
      : reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded32Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::additions_four_bytes() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
  return _internal_additions_four_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::unsafe_arena_release_additions_four_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
  if (_internal_has_additions_four_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_additions_.additions_four_bytes_;
    _impl_.compressed_additions_.additions_four_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HashList::unsafe_arena_set_allocated_additions_four_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* additions_four_bytes) {
  clear_compressed_additions();
  if (additions_four_bytes) {
    set_has_additions_four_bytes();
    _impl_.compressed_additions_.additions_four_bytes_ = additions_four_bytes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::_internal_mutable_additions_four_bytes() {
  if (!_internal_has_additions_four_bytes()) {
    clear_compressed_additions();
    set_has_additions_four_bytes();
    _impl_.compressed_additions_.additions_four_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit >(GetArenaForAllocation());
  }
  return _impl_.compressed_additions_.additions_four_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::mutable_additions_four_bytes() {
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _msg = _internal_mutable_additions_four_bytes();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_four_bytes)
  return _msg;
}

// .mozilla.safebrowsing.v5.RiceDeltaEncoded64Bit additions_eight_bytes = 9;
inline bool HashList::_internal_has_additions_eight_bytes() const {
  return compressed_additions_case() == kAdditionsEightBytes;
}
inline bool HashList::has_additions_eight_bytes() const {
  return _internal_has_additions_eight_bytes();
}
inline void HashList::set_has_additions_eight_bytes() {
  _impl_._oneof_case_[0] = kAdditionsEightBytes;
}
inline void HashList::clear_additions_eight_bytes() {
  if (_internal_has_additions_eight_bytes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.compressed_additions_.additions_eight_bytes_;
    }
    clear_has_compressed_additions();
  }
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::release_additions_eight_bytes() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
  if (_internal_has_additions_eight_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* temp = _impl_.compressed_additions_.additions_eight_bytes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.compressed_additions_.additions_eight_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& HashList::_internal_additions_eight_bytes() const {
  return _internal_has_additions_eight_bytes()
      ? *_impl_.compressed_additions_.additions_eight_bytes_
      : reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded64Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit& HashList::additions_eight_bytes() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
  return _internal_additions_eight_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::unsafe_arena_release_additions_eight_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
  if (_internal_has_additions_eight_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* temp = _impl_.compressed_additions_.additions_eight_bytes_;
    _impl_.compressed_additions_.additions_eight_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HashList::unsafe_arena_set_allocated_additions_eight_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* additions_eight_bytes) {
  clear_compressed_additions();
  if (additions_eight_bytes) {
    set_has_additions_eight_bytes();
    _impl_.compressed_additions_.additions_eight_bytes_ = additions_eight_bytes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::_internal_mutable_additions_eight_bytes() {
  if (!_internal_has_additions_eight_bytes()) {
    clear_compressed_additions();
    set_has_additions_eight_bytes();
    _impl_.compressed_additions_.additions_eight_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit >(GetArenaForAllocation());
  }
  return _impl_.compressed_additions_.additions_eight_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* HashList::mutable_additions_eight_bytes() {
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded64Bit* _msg = _internal_mutable_additions_eight_bytes();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_eight_bytes)
  return _msg;
}

// .mozilla.safebrowsing.v5.RiceDeltaEncoded128Bit additions_sixteen_bytes = 10;
inline bool HashList::_internal_has_additions_sixteen_bytes() const {
  return compressed_additions_case() == kAdditionsSixteenBytes;
}
inline bool HashList::has_additions_sixteen_bytes() const {
  return _internal_has_additions_sixteen_bytes();
}
inline void HashList::set_has_additions_sixteen_bytes() {
  _impl_._oneof_case_[0] = kAdditionsSixteenBytes;
}
inline void HashList::clear_additions_sixteen_bytes() {
  if (_internal_has_additions_sixteen_bytes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.compressed_additions_.additions_sixteen_bytes_;
    }
    clear_has_compressed_additions();
  }
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::release_additions_sixteen_bytes() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
  if (_internal_has_additions_sixteen_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* temp = _impl_.compressed_additions_.additions_sixteen_bytes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.compressed_additions_.additions_sixteen_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& HashList::_internal_additions_sixteen_bytes() const {
  return _internal_has_additions_sixteen_bytes()
      ? *_impl_.compressed_additions_.additions_sixteen_bytes_
      : reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded128Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit& HashList::additions_sixteen_bytes() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
  return _internal_additions_sixteen_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::unsafe_arena_release_additions_sixteen_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
  if (_internal_has_additions_sixteen_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* temp = _impl_.compressed_additions_.additions_sixteen_bytes_;
    _impl_.compressed_additions_.additions_sixteen_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HashList::unsafe_arena_set_allocated_additions_sixteen_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* additions_sixteen_bytes) {
  clear_compressed_additions();
  if (additions_sixteen_bytes) {
    set_has_additions_sixteen_bytes();
    _impl_.compressed_additions_.additions_sixteen_bytes_ = additions_sixteen_bytes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::_internal_mutable_additions_sixteen_bytes() {
  if (!_internal_has_additions_sixteen_bytes()) {
    clear_compressed_additions();
    set_has_additions_sixteen_bytes();
    _impl_.compressed_additions_.additions_sixteen_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit >(GetArenaForAllocation());
  }
  return _impl_.compressed_additions_.additions_sixteen_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* HashList::mutable_additions_sixteen_bytes() {
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded128Bit* _msg = _internal_mutable_additions_sixteen_bytes();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_sixteen_bytes)
  return _msg;
}

// .mozilla.safebrowsing.v5.RiceDeltaEncoded256Bit additions_thirty_two_bytes = 11;
inline bool HashList::_internal_has_additions_thirty_two_bytes() const {
  return compressed_additions_case() == kAdditionsThirtyTwoBytes;
}
inline bool HashList::has_additions_thirty_two_bytes() const {
  return _internal_has_additions_thirty_two_bytes();
}
inline void HashList::set_has_additions_thirty_two_bytes() {
  _impl_._oneof_case_[0] = kAdditionsThirtyTwoBytes;
}
inline void HashList::clear_additions_thirty_two_bytes() {
  if (_internal_has_additions_thirty_two_bytes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.compressed_additions_.additions_thirty_two_bytes_;
    }
    clear_has_compressed_additions();
  }
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::release_additions_thirty_two_bytes() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
  if (_internal_has_additions_thirty_two_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* temp = _impl_.compressed_additions_.additions_thirty_two_bytes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.compressed_additions_.additions_thirty_two_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& HashList::_internal_additions_thirty_two_bytes() const {
  return _internal_has_additions_thirty_two_bytes()
      ? *_impl_.compressed_additions_.additions_thirty_two_bytes_
      : reinterpret_cast< ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit&>(::mozilla::safebrowsing::v5::_RiceDeltaEncoded256Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit& HashList::additions_thirty_two_bytes() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
  return _internal_additions_thirty_two_bytes();
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::unsafe_arena_release_additions_thirty_two_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
  if (_internal_has_additions_thirty_two_bytes()) {
    clear_has_compressed_additions();
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* temp = _impl_.compressed_additions_.additions_thirty_two_bytes_;
    _impl_.compressed_additions_.additions_thirty_two_bytes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HashList::unsafe_arena_set_allocated_additions_thirty_two_bytes(::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* additions_thirty_two_bytes) {
  clear_compressed_additions();
  if (additions_thirty_two_bytes) {
    set_has_additions_thirty_two_bytes();
    _impl_.compressed_additions_.additions_thirty_two_bytes_ = additions_thirty_two_bytes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::_internal_mutable_additions_thirty_two_bytes() {
  if (!_internal_has_additions_thirty_two_bytes()) {
    clear_compressed_additions();
    set_has_additions_thirty_two_bytes();
    _impl_.compressed_additions_.additions_thirty_two_bytes_ = CreateMaybeMessage< ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit >(GetArenaForAllocation());
  }
  return _impl_.compressed_additions_.additions_thirty_two_bytes_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* HashList::mutable_additions_thirty_two_bytes() {
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded256Bit* _msg = _internal_mutable_additions_thirty_two_bytes();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.additions_thirty_two_bytes)
  return _msg;
}

// string name = 1;
inline void HashList::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& HashList::name() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashList::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.name)
}
inline std::string* HashList::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.name)
  return _s;
}
inline const std::string& HashList::_internal_name() const {
  return _impl_.name_.Get();
}
inline void HashList::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* HashList::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* HashList::release_name() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.name)
  return _impl_.name_.Release();
}
inline void HashList::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.name)
}

// bytes version = 2;
inline void HashList::clear_version() {
  _impl_.version_.ClearToEmpty();
}
inline const std::string& HashList::version() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashList::set_version(ArgT0&& arg0, ArgT... args) {
 
 _impl_.version_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.version)
}
inline std::string* HashList::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.version)
  return _s;
}
inline const std::string& HashList::_internal_version() const {
  return _impl_.version_.Get();
}
inline void HashList::_internal_set_version(const std::string& value) {
  
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* HashList::_internal_mutable_version() {
  
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* HashList::release_version() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.version)
  return _impl_.version_.Release();
}
inline void HashList::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    
  } else {
    
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.version)
}

// bool partial_update = 3;
inline void HashList::clear_partial_update() {
  _impl_.partial_update_ = false;
}
inline bool HashList::_internal_partial_update() const {
  return _impl_.partial_update_;
}
inline bool HashList::partial_update() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.partial_update)
  return _internal_partial_update();
}
inline void HashList::_internal_set_partial_update(bool value) {
  
  _impl_.partial_update_ = value;
}
inline void HashList::set_partial_update(bool value) {
  _internal_set_partial_update(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.partial_update)
}

// .mozilla.safebrowsing.v5.RiceDeltaEncoded32Bit compressed_removals = 5;
inline bool HashList::_internal_has_compressed_removals() const {
  return this != internal_default_instance() && _impl_.compressed_removals_ != nullptr;
}
inline bool HashList::has_compressed_removals() const {
  return _internal_has_compressed_removals();
}
inline void HashList::clear_compressed_removals() {
  if (GetArenaForAllocation() == nullptr && _impl_.compressed_removals_ != nullptr) {
    delete _impl_.compressed_removals_;
  }
  _impl_.compressed_removals_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::_internal_compressed_removals() const {
  const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* p = _impl_.compressed_removals_;
  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit&>(
      ::mozilla::safebrowsing::v5::_RiceDeltaEncoded32Bit_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit& HashList::compressed_removals() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.compressed_removals)
  return _internal_compressed_removals();
}
inline void HashList::unsafe_arena_set_allocated_compressed_removals(
    ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compressed_removals_);
  }
  _impl_.compressed_removals_ = compressed_removals;
  if (compressed_removals) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.compressed_removals)
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::release_compressed_removals() {
  
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_removals_;
  _impl_.compressed_removals_ = 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 ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::unsafe_arena_release_compressed_removals() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.compressed_removals)
  
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* temp = _impl_.compressed_removals_;
  _impl_.compressed_removals_ = nullptr;
  return temp;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::_internal_mutable_compressed_removals() {
  
  if (_impl_.compressed_removals_ == nullptr) {
    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit>(GetArenaForAllocation());
    _impl_.compressed_removals_ = p;
  }
  return _impl_.compressed_removals_;
}
inline ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* HashList::mutable_compressed_removals() {
  ::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* _msg = _internal_mutable_compressed_removals();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.compressed_removals)
  return _msg;
}
inline void HashList::set_allocated_compressed_removals(::mozilla::safebrowsing::v5::RiceDeltaEncoded32Bit* compressed_removals) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.compressed_removals_;
  }
  if (compressed_removals) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compressed_removals);
    if (message_arena != submessage_arena) {
      compressed_removals = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, compressed_removals, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.compressed_removals_ = compressed_removals;
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.compressed_removals)
}

// .mozilla.safebrowsing.v5.Duration minimum_wait_duration = 6;
inline bool HashList::_internal_has_minimum_wait_duration() const {
  return this != internal_default_instance() && _impl_.minimum_wait_duration_ != nullptr;
}
inline bool HashList::has_minimum_wait_duration() const {
  return _internal_has_minimum_wait_duration();
}
inline void HashList::clear_minimum_wait_duration() {
  if (GetArenaForAllocation() == nullptr && _impl_.minimum_wait_duration_ != nullptr) {
    delete _impl_.minimum_wait_duration_;
  }
  _impl_.minimum_wait_duration_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::Duration& HashList::_internal_minimum_wait_duration() const {
  const ::mozilla::safebrowsing::v5::Duration* p = _impl_.minimum_wait_duration_;
  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::Duration&>(
      ::mozilla::safebrowsing::v5::_Duration_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::Duration& HashList::minimum_wait_duration() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
  return _internal_minimum_wait_duration();
}
inline void HashList::unsafe_arena_set_allocated_minimum_wait_duration(
    ::mozilla::safebrowsing::v5::Duration* minimum_wait_duration) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.minimum_wait_duration_);
  }
  _impl_.minimum_wait_duration_ = minimum_wait_duration;
  if (minimum_wait_duration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::release_minimum_wait_duration() {
  
  ::mozilla::safebrowsing::v5::Duration* temp = _impl_.minimum_wait_duration_;
  _impl_.minimum_wait_duration_ = 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 ::mozilla::safebrowsing::v5::Duration* HashList::unsafe_arena_release_minimum_wait_duration() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
  
  ::mozilla::safebrowsing::v5::Duration* temp = _impl_.minimum_wait_duration_;
  _impl_.minimum_wait_duration_ = nullptr;
  return temp;
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::_internal_mutable_minimum_wait_duration() {
  
  if (_impl_.minimum_wait_duration_ == nullptr) {
    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::Duration>(GetArenaForAllocation());
    _impl_.minimum_wait_duration_ = p;
  }
  return _impl_.minimum_wait_duration_;
}
inline ::mozilla::safebrowsing::v5::Duration* HashList::mutable_minimum_wait_duration() {
  ::mozilla::safebrowsing::v5::Duration* _msg = _internal_mutable_minimum_wait_duration();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
  return _msg;
}
inline void HashList::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::v5::Duration* minimum_wait_duration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.minimum_wait_duration_;
  }
  if (minimum_wait_duration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(minimum_wait_duration);
    if (message_arena != submessage_arena) {
      minimum_wait_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, minimum_wait_duration, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.minimum_wait_duration_ = minimum_wait_duration;
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.minimum_wait_duration)
}

// bytes sha256_checksum = 7;
inline void HashList::clear_sha256_checksum() {
  _impl_.sha256_checksum_.ClearToEmpty();
}
inline const std::string& HashList::sha256_checksum() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.sha256_checksum)
  return _internal_sha256_checksum();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HashList::set_sha256_checksum(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sha256_checksum_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.HashList.sha256_checksum)
}
inline std::string* HashList::mutable_sha256_checksum() {
  std::string* _s = _internal_mutable_sha256_checksum();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.sha256_checksum)
  return _s;
}
inline const std::string& HashList::_internal_sha256_checksum() const {
  return _impl_.sha256_checksum_.Get();
}
inline void HashList::_internal_set_sha256_checksum(const std::string& value) {
  
  _impl_.sha256_checksum_.Set(value, GetArenaForAllocation());
}
inline std::string* HashList::_internal_mutable_sha256_checksum() {
  
  return _impl_.sha256_checksum_.Mutable(GetArenaForAllocation());
}
inline std::string* HashList::release_sha256_checksum() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.sha256_checksum)
  return _impl_.sha256_checksum_.Release();
}
inline void HashList::set_allocated_sha256_checksum(std::string* sha256_checksum) {
  if (sha256_checksum != nullptr) {
    
  } else {
    
  }
  _impl_.sha256_checksum_.SetAllocated(sha256_checksum, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sha256_checksum_.IsDefault()) {
    _impl_.sha256_checksum_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.sha256_checksum)
}

// .mozilla.safebrowsing.v5.HashListMetadata metadata = 8;
inline bool HashList::_internal_has_metadata() const {
  return this != internal_default_instance() && _impl_.metadata_ != nullptr;
}
inline bool HashList::has_metadata() const {
  return _internal_has_metadata();
}
inline void HashList::clear_metadata() {
  if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
    delete _impl_.metadata_;
  }
  _impl_.metadata_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::HashListMetadata& HashList::_internal_metadata() const {
  const ::mozilla::safebrowsing::v5::HashListMetadata* p = _impl_.metadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::HashListMetadata&>(
      ::mozilla::safebrowsing::v5::_HashListMetadata_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::HashListMetadata& HashList::metadata() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.HashList.metadata)
  return _internal_metadata();
}
inline void HashList::unsafe_arena_set_allocated_metadata(
    ::mozilla::safebrowsing::v5::HashListMetadata* metadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
  }
  _impl_.metadata_ = metadata;
  if (metadata) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.HashList.metadata)
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::release_metadata() {
  
  ::mozilla::safebrowsing::v5::HashListMetadata* temp = _impl_.metadata_;
  _impl_.metadata_ = 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 ::mozilla::safebrowsing::v5::HashListMetadata* HashList::unsafe_arena_release_metadata() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.HashList.metadata)
  
  ::mozilla::safebrowsing::v5::HashListMetadata* temp = _impl_.metadata_;
  _impl_.metadata_ = nullptr;
  return temp;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::_internal_mutable_metadata() {
  
  if (_impl_.metadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::HashListMetadata>(GetArenaForAllocation());
    _impl_.metadata_ = p;
  }
  return _impl_.metadata_;
}
inline ::mozilla::safebrowsing::v5::HashListMetadata* HashList::mutable_metadata() {
  ::mozilla::safebrowsing::v5::HashListMetadata* _msg = _internal_mutable_metadata();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.HashList.metadata)
  return _msg;
}
inline void HashList::set_allocated_metadata(::mozilla::safebrowsing::v5::HashListMetadata* metadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.metadata_;
  }
  if (metadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata);
    if (message_arena != submessage_arena) {
      metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, metadata, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.metadata_ = metadata;
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.HashList.metadata)
}

inline bool HashList::has_compressed_additions() const {
  return compressed_additions_case() != COMPRESSED_ADDITIONS_NOT_SET;
}
inline void HashList::clear_has_compressed_additions() {
  _impl_._oneof_case_[0] = COMPRESSED_ADDITIONS_NOT_SET;
}
inline HashList::CompressedAdditionsCase HashList::compressed_additions_case() const {
  return HashList::CompressedAdditionsCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// BatchGetHashListsRequest

// repeated string names = 1;
inline int BatchGetHashListsRequest::_internal_names_size() const {
  return _impl_.names_.size();
}
inline int BatchGetHashListsRequest::names_size() const {
  return _internal_names_size();
}
inline void BatchGetHashListsRequest::clear_names() {
  _impl_.names_.Clear();
}
inline std::string* BatchGetHashListsRequest::add_names() {
  std::string* _s = _internal_add_names();
  // @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
  return _s;
}
inline const std::string& BatchGetHashListsRequest::_internal_names(int index) const {
  return _impl_.names_.Get(index);
}
inline const std::string& BatchGetHashListsRequest::names(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
  return _internal_names(index);
}
inline std::string* BatchGetHashListsRequest::mutable_names(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
  return _impl_.names_.Mutable(index);
}
inline void BatchGetHashListsRequest::set_names(int index, const std::string& value) {
  _impl_.names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::set_names(int index, std::string&& value) {
  _impl_.names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::set_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::set_names(int index, const char* value, size_t size) {
  _impl_.names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline std::string* BatchGetHashListsRequest::_internal_add_names() {
  return _impl_.names_.Add();
}
inline void BatchGetHashListsRequest::add_names(const std::string& value) {
  _impl_.names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::add_names(std::string&& value) {
  _impl_.names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::add_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline void BatchGetHashListsRequest::add_names(const char* value, size_t size) {
  _impl_.names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BatchGetHashListsRequest::names() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
  return _impl_.names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BatchGetHashListsRequest::mutable_names() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.names)
  return &_impl_.names_;
}

// repeated bytes version = 2;
inline int BatchGetHashListsRequest::_internal_version_size() const {
  return _impl_.version_.size();
}
inline int BatchGetHashListsRequest::version_size() const {
  return _internal_version_size();
}
inline void BatchGetHashListsRequest::clear_version() {
  _impl_.version_.Clear();
}
inline std::string* BatchGetHashListsRequest::add_version() {
  std::string* _s = _internal_add_version();
  // @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
  return _s;
}
inline const std::string& BatchGetHashListsRequest::_internal_version(int index) const {
  return _impl_.version_.Get(index);
}
inline const std::string& BatchGetHashListsRequest::version(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
  return _internal_version(index);
}
inline std::string* BatchGetHashListsRequest::mutable_version(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
  return _impl_.version_.Mutable(index);
}
inline void BatchGetHashListsRequest::set_version(int index, const std::string& value) {
  _impl_.version_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::set_version(int index, std::string&& value) {
  _impl_.version_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::set_version(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.version_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::set_version(int index, const void* value, size_t size) {
  _impl_.version_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline std::string* BatchGetHashListsRequest::_internal_add_version() {
  return _impl_.version_.Add();
}
inline void BatchGetHashListsRequest::add_version(const std::string& value) {
  _impl_.version_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::add_version(std::string&& value) {
  _impl_.version_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::add_version(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.version_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline void BatchGetHashListsRequest::add_version(const void* value, size_t size) {
  _impl_.version_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BatchGetHashListsRequest::version() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
  return _impl_.version_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BatchGetHashListsRequest::mutable_version() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.BatchGetHashListsRequest.version)
  return &_impl_.version_;
}

// .mozilla.safebrowsing.v5.SizeConstraints size_constraints = 4;
inline bool BatchGetHashListsRequest::_internal_has_size_constraints() const {
  return this != internal_default_instance() && _impl_.size_constraints_ != nullptr;
}
inline bool BatchGetHashListsRequest::has_size_constraints() const {
  return _internal_has_size_constraints();
}
inline void BatchGetHashListsRequest::clear_size_constraints() {
  if (GetArenaForAllocation() == nullptr && _impl_.size_constraints_ != nullptr) {
    delete _impl_.size_constraints_;
  }
  _impl_.size_constraints_ = nullptr;
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& BatchGetHashListsRequest::_internal_size_constraints() const {
  const ::mozilla::safebrowsing::v5::SizeConstraints* p = _impl_.size_constraints_;
  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::v5::SizeConstraints&>(
      ::mozilla::safebrowsing::v5::_SizeConstraints_default_instance_);
}
inline const ::mozilla::safebrowsing::v5::SizeConstraints& BatchGetHashListsRequest::size_constraints() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
  return _internal_size_constraints();
}
inline void BatchGetHashListsRequest::unsafe_arena_set_allocated_size_constraints(
    ::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.size_constraints_);
  }
  _impl_.size_constraints_ = size_constraints;
  if (size_constraints) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::release_size_constraints() {
  
  ::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
  _impl_.size_constraints_ = 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 ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::unsafe_arena_release_size_constraints() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
  
  ::mozilla::safebrowsing::v5::SizeConstraints* temp = _impl_.size_constraints_;
  _impl_.size_constraints_ = nullptr;
  return temp;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::_internal_mutable_size_constraints() {
  
  if (_impl_.size_constraints_ == nullptr) {
    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::v5::SizeConstraints>(GetArenaForAllocation());
    _impl_.size_constraints_ = p;
  }
  return _impl_.size_constraints_;
}
inline ::mozilla::safebrowsing::v5::SizeConstraints* BatchGetHashListsRequest::mutable_size_constraints() {
  ::mozilla::safebrowsing::v5::SizeConstraints* _msg = _internal_mutable_size_constraints();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
  return _msg;
}
inline void BatchGetHashListsRequest::set_allocated_size_constraints(::mozilla::safebrowsing::v5::SizeConstraints* size_constraints) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.size_constraints_;
  }
  if (size_constraints) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(size_constraints);
    if (message_arena != submessage_arena) {
      size_constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, size_constraints, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.size_constraints_ = size_constraints;
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.BatchGetHashListsRequest.size_constraints)
}

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

// BatchGetHashListsResponse

// repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
inline int BatchGetHashListsResponse::_internal_hash_lists_size() const {
  return _impl_.hash_lists_.size();
}
inline int BatchGetHashListsResponse::hash_lists_size() const {
  return _internal_hash_lists_size();
}
inline void BatchGetHashListsResponse::clear_hash_lists() {
  _impl_.hash_lists_.Clear();
}
inline ::mozilla::safebrowsing::v5::HashList* BatchGetHashListsResponse::mutable_hash_lists(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
  return _impl_.hash_lists_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
BatchGetHashListsResponse::mutable_hash_lists() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
  return &_impl_.hash_lists_;
}
inline const ::mozilla::safebrowsing::v5::HashList& BatchGetHashListsResponse::_internal_hash_lists(int index) const {
  return _impl_.hash_lists_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::HashList& BatchGetHashListsResponse::hash_lists(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
  return _internal_hash_lists(index);
}
inline ::mozilla::safebrowsing::v5::HashList* BatchGetHashListsResponse::_internal_add_hash_lists() {
  return _impl_.hash_lists_.Add();
}
inline ::mozilla::safebrowsing::v5::HashList* BatchGetHashListsResponse::add_hash_lists() {
  ::mozilla::safebrowsing::v5::HashList* _add = _internal_add_hash_lists();
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
BatchGetHashListsResponse::hash_lists() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.BatchGetHashListsResponse.hash_lists)
  return _impl_.hash_lists_;
}

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

// ListHashListsRequest

// int32 page_size = 1;
inline void ListHashListsRequest::clear_page_size() {
  _impl_.page_size_ = 0;
}
inline int32_t ListHashListsRequest::_internal_page_size() const {
  return _impl_.page_size_;
}
inline int32_t ListHashListsRequest::page_size() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsRequest.page_size)
  return _internal_page_size();
}
inline void ListHashListsRequest::_internal_set_page_size(int32_t value) {
  
  _impl_.page_size_ = value;
}
inline void ListHashListsRequest::set_page_size(int32_t value) {
  _internal_set_page_size(value);
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.ListHashListsRequest.page_size)
}

// string page_token = 2;
inline void ListHashListsRequest::clear_page_token() {
  _impl_.page_token_.ClearToEmpty();
}
inline const std::string& ListHashListsRequest::page_token() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
  return _internal_page_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ListHashListsRequest::set_page_token(ArgT0&& arg0, ArgT... args) {
 
 _impl_.page_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
}
inline std::string* ListHashListsRequest::mutable_page_token() {
  std::string* _s = _internal_mutable_page_token();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
  return _s;
}
inline const std::string& ListHashListsRequest::_internal_page_token() const {
  return _impl_.page_token_.Get();
}
inline void ListHashListsRequest::_internal_set_page_token(const std::string& value) {
  
  _impl_.page_token_.Set(value, GetArenaForAllocation());
}
inline std::string* ListHashListsRequest::_internal_mutable_page_token() {
  
  return _impl_.page_token_.Mutable(GetArenaForAllocation());
}
inline std::string* ListHashListsRequest::release_page_token() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
  return _impl_.page_token_.Release();
}
inline void ListHashListsRequest::set_allocated_page_token(std::string* page_token) {
  if (page_token != nullptr) {
    
  } else {
    
  }
  _impl_.page_token_.SetAllocated(page_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.page_token_.IsDefault()) {
    _impl_.page_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.ListHashListsRequest.page_token)
}

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

// ListHashListsResponse

// repeated .mozilla.safebrowsing.v5.HashList hash_lists = 1;
inline int ListHashListsResponse::_internal_hash_lists_size() const {
  return _impl_.hash_lists_.size();
}
inline int ListHashListsResponse::hash_lists_size() const {
  return _internal_hash_lists_size();
}
inline void ListHashListsResponse::clear_hash_lists() {
  _impl_.hash_lists_.Clear();
}
inline ::mozilla::safebrowsing::v5::HashList* ListHashListsResponse::mutable_hash_lists(int index) {
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
  return _impl_.hash_lists_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >*
ListHashListsResponse::mutable_hash_lists() {
  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
  return &_impl_.hash_lists_;
}
inline const ::mozilla::safebrowsing::v5::HashList& ListHashListsResponse::_internal_hash_lists(int index) const {
  return _impl_.hash_lists_.Get(index);
}
inline const ::mozilla::safebrowsing::v5::HashList& ListHashListsResponse::hash_lists(int index) const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
  return _internal_hash_lists(index);
}
inline ::mozilla::safebrowsing::v5::HashList* ListHashListsResponse::_internal_add_hash_lists() {
  return _impl_.hash_lists_.Add();
}
inline ::mozilla::safebrowsing::v5::HashList* ListHashListsResponse::add_hash_lists() {
  ::mozilla::safebrowsing::v5::HashList* _add = _internal_add_hash_lists();
  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::v5::HashList >&
ListHashListsResponse::hash_lists() const {
  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.v5.ListHashListsResponse.hash_lists)
  return _impl_.hash_lists_;
}

// string next_page_token = 2;
inline void ListHashListsResponse::clear_next_page_token() {
  _impl_.next_page_token_.ClearToEmpty();
}
inline const std::string& ListHashListsResponse::next_page_token() const {
  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
  return _internal_next_page_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ListHashListsResponse::set_next_page_token(ArgT0&& arg0, ArgT... args) {
 
 _impl_.next_page_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
}
inline std::string* ListHashListsResponse::mutable_next_page_token() {
  std::string* _s = _internal_mutable_next_page_token();
  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
  return _s;
}
inline const std::string& ListHashListsResponse::_internal_next_page_token() const {
  return _impl_.next_page_token_.Get();
}
inline void ListHashListsResponse::_internal_set_next_page_token(const std::string& value) {
  
  _impl_.next_page_token_.Set(value, GetArenaForAllocation());
}
inline std::string* ListHashListsResponse::_internal_mutable_next_page_token() {
  
  return _impl_.next_page_token_.Mutable(GetArenaForAllocation());
}
inline std::string* ListHashListsResponse::release_next_page_token() {
  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
  return _impl_.next_page_token_.Release();
}
inline void ListHashListsResponse::set_allocated_next_page_token(std::string* next_page_token) {
  if (next_page_token != nullptr) {
    
  } else {
    
  }
  _impl_.next_page_token_.SetAllocated(next_page_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.next_page_token_.IsDefault()) {
    _impl_.next_page_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.v5.ListHashListsResponse.next_page_token)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace v5
}  // namespace safebrowsing
}  // namespace mozilla

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::HashListMetadata_HashLength> : ::std::true_type {};
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::ThreatType> : ::std::true_type {};
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::LikelySafeType> : ::std::true_type {};
template <> struct is_proto_enum< ::mozilla::safebrowsing::v5::ThreatAttribute> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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