Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 10010 insertions, 0 deletions

diff --git a/toolkit/components/url-classifier/chromium/safebrowsing.pb.h b/toolkit/components/url-classifier/chromium/safebrowsing.pb.h
new file mode 100644
index 0000000000..194b2c410f
--- /dev/null
+++ b/toolkit/components/url-classifier/chromium/safebrowsing.pb.h
@@ -0,0 +1,10010 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: safebrowsing.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_safebrowsing_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_safebrowsing_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_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_safebrowsing_2eproto {
+  static const uint32_t offsets[];
+};
+namespace mozilla {
+namespace safebrowsing {
+class Checksum;
+struct ChecksumDefaultTypeInternal;
+extern ChecksumDefaultTypeInternal _Checksum_default_instance_;
+class ChromeClientInfo;
+struct ChromeClientInfoDefaultTypeInternal;
+extern ChromeClientInfoDefaultTypeInternal _ChromeClientInfo_default_instance_;
+class ClientInfo;
+struct ClientInfoDefaultTypeInternal;
+extern ClientInfoDefaultTypeInternal _ClientInfo_default_instance_;
+class Duration;
+struct DurationDefaultTypeInternal;
+extern DurationDefaultTypeInternal _Duration_default_instance_;
+class FetchThreatListUpdatesRequest;
+struct FetchThreatListUpdatesRequestDefaultTypeInternal;
+extern FetchThreatListUpdatesRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_default_instance_;
+class FetchThreatListUpdatesRequest_ListUpdateRequest;
+struct FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal;
+extern FetchThreatListUpdatesRequest_ListUpdateRequestDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_;
+class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints;
+struct FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal;
+extern FetchThreatListUpdatesRequest_ListUpdateRequest_ConstraintsDefaultTypeInternal _FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_;
+class FetchThreatListUpdatesResponse;
+struct FetchThreatListUpdatesResponseDefaultTypeInternal;
+extern FetchThreatListUpdatesResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_default_instance_;
+class FetchThreatListUpdatesResponse_ListUpdateResponse;
+struct FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal;
+extern FetchThreatListUpdatesResponse_ListUpdateResponseDefaultTypeInternal _FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_;
+class FindFullHashesRequest;
+struct FindFullHashesRequestDefaultTypeInternal;
+extern FindFullHashesRequestDefaultTypeInternal _FindFullHashesRequest_default_instance_;
+class FindFullHashesResponse;
+struct FindFullHashesResponseDefaultTypeInternal;
+extern FindFullHashesResponseDefaultTypeInternal _FindFullHashesResponse_default_instance_;
+class FindThreatMatchesRequest;
+struct FindThreatMatchesRequestDefaultTypeInternal;
+extern FindThreatMatchesRequestDefaultTypeInternal _FindThreatMatchesRequest_default_instance_;
+class FindThreatMatchesResponse;
+struct FindThreatMatchesResponseDefaultTypeInternal;
+extern FindThreatMatchesResponseDefaultTypeInternal _FindThreatMatchesResponse_default_instance_;
+class ListThreatListsResponse;
+struct ListThreatListsResponseDefaultTypeInternal;
+extern ListThreatListsResponseDefaultTypeInternal _ListThreatListsResponse_default_instance_;
+class RawHashes;
+struct RawHashesDefaultTypeInternal;
+extern RawHashesDefaultTypeInternal _RawHashes_default_instance_;
+class RawIndices;
+struct RawIndicesDefaultTypeInternal;
+extern RawIndicesDefaultTypeInternal _RawIndices_default_instance_;
+class RiceDeltaEncoding;
+struct RiceDeltaEncodingDefaultTypeInternal;
+extern RiceDeltaEncodingDefaultTypeInternal _RiceDeltaEncoding_default_instance_;
+class ThreatEntry;
+struct ThreatEntryDefaultTypeInternal;
+extern ThreatEntryDefaultTypeInternal _ThreatEntry_default_instance_;
+class ThreatEntryMetadata;
+struct ThreatEntryMetadataDefaultTypeInternal;
+extern ThreatEntryMetadataDefaultTypeInternal _ThreatEntryMetadata_default_instance_;
+class ThreatEntryMetadata_MetadataEntry;
+struct ThreatEntryMetadata_MetadataEntryDefaultTypeInternal;
+extern ThreatEntryMetadata_MetadataEntryDefaultTypeInternal _ThreatEntryMetadata_MetadataEntry_default_instance_;
+class ThreatEntrySet;
+struct ThreatEntrySetDefaultTypeInternal;
+extern ThreatEntrySetDefaultTypeInternal _ThreatEntrySet_default_instance_;
+class ThreatHit;
+struct ThreatHitDefaultTypeInternal;
+extern ThreatHitDefaultTypeInternal _ThreatHit_default_instance_;
+class ThreatHit_ThreatSource;
+struct ThreatHit_ThreatSourceDefaultTypeInternal;
+extern ThreatHit_ThreatSourceDefaultTypeInternal _ThreatHit_ThreatSource_default_instance_;
+class ThreatHit_UserInfo;
+struct ThreatHit_UserInfoDefaultTypeInternal;
+extern ThreatHit_UserInfoDefaultTypeInternal _ThreatHit_UserInfo_default_instance_;
+class ThreatInfo;
+struct ThreatInfoDefaultTypeInternal;
+extern ThreatInfoDefaultTypeInternal _ThreatInfo_default_instance_;
+class ThreatListDescriptor;
+struct ThreatListDescriptorDefaultTypeInternal;
+extern ThreatListDescriptorDefaultTypeInternal _ThreatListDescriptor_default_instance_;
+class ThreatMatch;
+struct ThreatMatchDefaultTypeInternal;
+extern ThreatMatchDefaultTypeInternal _ThreatMatch_default_instance_;
+}  // namespace safebrowsing
+}  // namespace mozilla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::mozilla::safebrowsing::Checksum* Arena::CreateMaybeMessage<::mozilla::safebrowsing::Checksum>(Arena*);
+template<> ::mozilla::safebrowsing::ChromeClientInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ChromeClientInfo>(Arena*);
+template<> ::mozilla::safebrowsing::ClientInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(Arena*);
+template<> ::mozilla::safebrowsing::Duration* Arena::CreateMaybeMessage<::mozilla::safebrowsing::Duration>(Arena*);
+template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest>(Arena*);
+template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest>(Arena*);
+template<> ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(Arena*);
+template<> ::mozilla::safebrowsing::FetchThreatListUpdatesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesResponse>(Arena*);
+template<> ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse>(Arena*);
+template<> ::mozilla::safebrowsing::FindFullHashesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindFullHashesRequest>(Arena*);
+template<> ::mozilla::safebrowsing::FindFullHashesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindFullHashesResponse>(Arena*);
+template<> ::mozilla::safebrowsing::FindThreatMatchesRequest* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindThreatMatchesRequest>(Arena*);
+template<> ::mozilla::safebrowsing::FindThreatMatchesResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::FindThreatMatchesResponse>(Arena*);
+template<> ::mozilla::safebrowsing::ListThreatListsResponse* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ListThreatListsResponse>(Arena*);
+template<> ::mozilla::safebrowsing::RawHashes* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RawHashes>(Arena*);
+template<> ::mozilla::safebrowsing::RawIndices* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RawIndices>(Arena*);
+template<> ::mozilla::safebrowsing::RiceDeltaEncoding* Arena::CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatEntry* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatEntryMetadata* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatEntrySet* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntrySet>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatHit* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatHit_ThreatSource* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_ThreatSource>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatHit_UserInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_UserInfo>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatInfo* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatListDescriptor* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatListDescriptor>(Arena*);
+template<> ::mozilla::safebrowsing::ThreatMatch* Arena::CreateMaybeMessage<::mozilla::safebrowsing::ThreatMatch>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace mozilla {
+namespace safebrowsing {
+
+enum FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType : int {
+  FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED = 0,
+  FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE = 1,
+  FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE = 2
+};
+bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value);
+constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED;
+constexpr FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE;
+constexpr int FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX + 1;
+
+const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
+template<typename T>
+inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name.");
+  return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(static_cast<FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType>(enum_t_value));
+}
+bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType* value);
+enum ThreatHit_ThreatSourceType : int {
+  ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED = 0,
+  ThreatHit_ThreatSourceType_MATCHING_URL = 1,
+  ThreatHit_ThreatSourceType_TAB_URL = 2,
+  ThreatHit_ThreatSourceType_TAB_REDIRECT = 3,
+  ThreatHit_ThreatSourceType_TAB_RESOURCE = 4
+};
+bool ThreatHit_ThreatSourceType_IsValid(int value);
+constexpr ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MIN = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED;
+constexpr ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MAX = ThreatHit_ThreatSourceType_TAB_RESOURCE;
+constexpr int ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE = ThreatHit_ThreatSourceType_ThreatSourceType_MAX + 1;
+
+const std::string& ThreatHit_ThreatSourceType_Name(ThreatHit_ThreatSourceType value);
+template<typename T>
+inline const std::string& ThreatHit_ThreatSourceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ThreatHit_ThreatSourceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ThreatHit_ThreatSourceType_Name.");
+  return ThreatHit_ThreatSourceType_Name(static_cast<ThreatHit_ThreatSourceType>(enum_t_value));
+}
+bool ThreatHit_ThreatSourceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatHit_ThreatSourceType* value);
+enum ChromeClientInfo_SafeBrowsingReportingPopulation : int {
+  ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED = 0,
+  ChromeClientInfo_SafeBrowsingReportingPopulation_OPT_OUT = 1,
+  ChromeClientInfo_SafeBrowsingReportingPopulation_EXTENDED = 2,
+  ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT = 3
+};
+bool ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(int value);
+constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MIN = ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED;
+constexpr ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX = ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT;
+constexpr int ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_ARRAYSIZE = ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX + 1;
+
+const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name(ChromeClientInfo_SafeBrowsingReportingPopulation value);
+template<typename T>
+inline const std::string& ChromeClientInfo_SafeBrowsingReportingPopulation_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ChromeClientInfo_SafeBrowsingReportingPopulation>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ChromeClientInfo_SafeBrowsingReportingPopulation_Name.");
+  return ChromeClientInfo_SafeBrowsingReportingPopulation_Name(static_cast<ChromeClientInfo_SafeBrowsingReportingPopulation>(enum_t_value));
+}
+bool ChromeClientInfo_SafeBrowsingReportingPopulation_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeClientInfo_SafeBrowsingReportingPopulation* value);
+enum ThreatType : int {
+  THREAT_TYPE_UNSPECIFIED = 0,
+  MALWARE_THREAT = 1,
+  SOCIAL_ENGINEERING_PUBLIC = 2,
+  UNWANTED_SOFTWARE = 3,
+  POTENTIALLY_HARMFUL_APPLICATION = 4,
+  SOCIAL_ENGINEERING = 5,
+  API_ABUSE = 6,
+  MALICIOUS_BINARY = 7,
+  CSD_WHITELIST = 8,
+  CSD_DOWNLOAD_WHITELIST = 9,
+  CLIENT_INCIDENT = 10,
+  SUBRESOURCE_FILTER = 13
+};
+bool ThreatType_IsValid(int value);
+constexpr ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED;
+constexpr ThreatType ThreatType_MAX = SUBRESOURCE_FILTER;
+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 PlatformType : int {
+  PLATFORM_TYPE_UNSPECIFIED = 0,
+  WINDOWS_PLATFORM = 1,
+  LINUX_PLATFORM = 2,
+  ANDROID_PLATFORM = 3,
+  OSX_PLATFORM = 4,
+  IOS_PLATFORM = 5,
+  ANY_PLATFORM = 6,
+  ALL_PLATFORMS = 7,
+  CHROME_PLATFORM = 8
+};
+bool PlatformType_IsValid(int value);
+constexpr PlatformType PlatformType_MIN = PLATFORM_TYPE_UNSPECIFIED;
+constexpr PlatformType PlatformType_MAX = CHROME_PLATFORM;
+constexpr int PlatformType_ARRAYSIZE = PlatformType_MAX + 1;
+
+const std::string& PlatformType_Name(PlatformType value);
+template<typename T>
+inline const std::string& PlatformType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlatformType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlatformType_Name.");
+  return PlatformType_Name(static_cast<PlatformType>(enum_t_value));
+}
+bool PlatformType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlatformType* value);
+enum CompressionType : int {
+  COMPRESSION_TYPE_UNSPECIFIED = 0,
+  RAW = 1,
+  RICE = 2
+};
+bool CompressionType_IsValid(int value);
+constexpr CompressionType CompressionType_MIN = COMPRESSION_TYPE_UNSPECIFIED;
+constexpr CompressionType CompressionType_MAX = RICE;
+constexpr int CompressionType_ARRAYSIZE = CompressionType_MAX + 1;
+
+const std::string& CompressionType_Name(CompressionType value);
+template<typename T>
+inline const std::string& CompressionType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, CompressionType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function CompressionType_Name.");
+  return CompressionType_Name(static_cast<CompressionType>(enum_t_value));
+}
+bool CompressionType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressionType* value);
+enum ThreatEntryType : int {
+  THREAT_ENTRY_TYPE_UNSPECIFIED = 0,
+  URL = 1,
+  EXECUTABLE = 2,
+  IP_RANGE = 3,
+  CHROME_EXTENSION = 4,
+  FILENAME = 5,
+  CERT = 6
+};
+bool ThreatEntryType_IsValid(int value);
+constexpr ThreatEntryType ThreatEntryType_MIN = THREAT_ENTRY_TYPE_UNSPECIFIED;
+constexpr ThreatEntryType ThreatEntryType_MAX = CERT;
+constexpr int ThreatEntryType_ARRAYSIZE = ThreatEntryType_MAX + 1;
+
+const std::string& ThreatEntryType_Name(ThreatEntryType value);
+template<typename T>
+inline const std::string& ThreatEntryType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ThreatEntryType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ThreatEntryType_Name.");
+  return ThreatEntryType_Name(static_cast<ThreatEntryType>(enum_t_value));
+}
+bool ThreatEntryType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ThreatEntryType* value);
+// ===================================================================
+
+class ThreatInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatInfo) */ {
+ public:
+  inline ThreatInfo() : ThreatInfo(nullptr) {}
+  ~ThreatInfo() override;
+  explicit PROTOBUF_CONSTEXPR ThreatInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatInfo(const ThreatInfo& from);
+  ThreatInfo(ThreatInfo&& from) noexcept
+    : ThreatInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatInfo& operator=(const ThreatInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatInfo& operator=(ThreatInfo&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatInfo* internal_default_instance() {
+    return reinterpret_cast<const ThreatInfo*>(
+               &_ThreatInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ThreatInfo& a, ThreatInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatInfo* 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(ThreatInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatInfo& from);
+  void MergeFrom(const ThreatInfo& 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(ThreatInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatInfo";
+  }
+  protected:
+  explicit ThreatInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kThreatTypesFieldNumber = 1,
+    kPlatformTypesFieldNumber = 2,
+    kThreatEntriesFieldNumber = 3,
+    kThreatEntryTypesFieldNumber = 4,
+  };
+  // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+  int threat_types_size() const;
+  private:
+  int _internal_threat_types_size() const;
+  public:
+  void clear_threat_types();
+  private:
+  ::mozilla::safebrowsing::ThreatType _internal_threat_types(int index) const;
+  void _internal_add_threat_types(::mozilla::safebrowsing::ThreatType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_types();
+  public:
+  ::mozilla::safebrowsing::ThreatType threat_types(int index) const;
+  void set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value);
+  void add_threat_types(::mozilla::safebrowsing::ThreatType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_types() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_types();
+
+  // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+  int platform_types_size() const;
+  private:
+  int _internal_platform_types_size() const;
+  public:
+  void clear_platform_types();
+  private:
+  ::mozilla::safebrowsing::PlatformType _internal_platform_types(int index) const;
+  void _internal_add_platform_types(::mozilla::safebrowsing::PlatformType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_platform_types();
+  public:
+  ::mozilla::safebrowsing::PlatformType platform_types(int index) const;
+  void set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value);
+  void add_platform_types(::mozilla::safebrowsing::PlatformType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& platform_types() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_platform_types();
+
+  // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+  int threat_entries_size() const;
+  private:
+  int _internal_threat_entries_size() const;
+  public:
+  void clear_threat_entries();
+  ::mozilla::safebrowsing::ThreatEntry* mutable_threat_entries(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >*
+      mutable_threat_entries();
+  private:
+  const ::mozilla::safebrowsing::ThreatEntry& _internal_threat_entries(int index) const;
+  ::mozilla::safebrowsing::ThreatEntry* _internal_add_threat_entries();
+  public:
+  const ::mozilla::safebrowsing::ThreatEntry& threat_entries(int index) const;
+  ::mozilla::safebrowsing::ThreatEntry* add_threat_entries();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >&
+      threat_entries() const;
+
+  // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+  int threat_entry_types_size() const;
+  private:
+  int _internal_threat_entry_types_size() const;
+  public:
+  void clear_threat_entry_types();
+  private:
+  ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_types(int index) const;
+  void _internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_threat_entry_types();
+  public:
+  ::mozilla::safebrowsing::ThreatEntryType threat_entry_types(int index) const;
+  void set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value);
+  void add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& threat_entry_types() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_threat_entry_types();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatInfo)
+ 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_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> platform_types_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry > threat_entries_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> threat_entry_types_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatMatch final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatMatch) */ {
+ public:
+  inline ThreatMatch() : ThreatMatch(nullptr) {}
+  ~ThreatMatch() override;
+  explicit PROTOBUF_CONSTEXPR ThreatMatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatMatch(const ThreatMatch& from);
+  ThreatMatch(ThreatMatch&& from) noexcept
+    : ThreatMatch() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatMatch& operator=(const ThreatMatch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatMatch& operator=(ThreatMatch&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatMatch& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatMatch* internal_default_instance() {
+    return reinterpret_cast<const ThreatMatch*>(
+               &_ThreatMatch_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ThreatMatch& a, ThreatMatch& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatMatch* 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(ThreatMatch* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatMatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatMatch>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatMatch& from);
+  void MergeFrom(const ThreatMatch& 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(ThreatMatch* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatMatch";
+  }
+  protected:
+  explicit ThreatMatch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kThreatFieldNumber = 3,
+    kThreatEntryMetadataFieldNumber = 4,
+    kCacheDurationFieldNumber = 5,
+    kThreatTypeFieldNumber = 1,
+    kPlatformTypeFieldNumber = 2,
+    kThreatEntryTypeFieldNumber = 6,
+  };
+  // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+  bool has_threat() const;
+  private:
+  bool _internal_has_threat() const;
+  public:
+  void clear_threat();
+  const ::mozilla::safebrowsing::ThreatEntry& threat() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatEntry* release_threat();
+  ::mozilla::safebrowsing::ThreatEntry* mutable_threat();
+  void set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat);
+  private:
+  const ::mozilla::safebrowsing::ThreatEntry& _internal_threat() const;
+  ::mozilla::safebrowsing::ThreatEntry* _internal_mutable_threat();
+  public:
+  void unsafe_arena_set_allocated_threat(
+      ::mozilla::safebrowsing::ThreatEntry* threat);
+  ::mozilla::safebrowsing::ThreatEntry* unsafe_arena_release_threat();
+
+  // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+  bool has_threat_entry_metadata() const;
+  private:
+  bool _internal_has_threat_entry_metadata() const;
+  public:
+  void clear_threat_entry_metadata();
+  const ::mozilla::safebrowsing::ThreatEntryMetadata& threat_entry_metadata() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatEntryMetadata* release_threat_entry_metadata();
+  ::mozilla::safebrowsing::ThreatEntryMetadata* mutable_threat_entry_metadata();
+  void set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata);
+  private:
+  const ::mozilla::safebrowsing::ThreatEntryMetadata& _internal_threat_entry_metadata() const;
+  ::mozilla::safebrowsing::ThreatEntryMetadata* _internal_mutable_threat_entry_metadata();
+  public:
+  void unsafe_arena_set_allocated_threat_entry_metadata(
+      ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata);
+  ::mozilla::safebrowsing::ThreatEntryMetadata* unsafe_arena_release_threat_entry_metadata();
+
+  // optional .mozilla.safebrowsing.Duration cache_duration = 5;
+  bool has_cache_duration() const;
+  private:
+  bool _internal_has_cache_duration() const;
+  public:
+  void clear_cache_duration();
+  const ::mozilla::safebrowsing::Duration& cache_duration() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_cache_duration();
+  ::mozilla::safebrowsing::Duration* mutable_cache_duration();
+  void set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration);
+  private:
+  const ::mozilla::safebrowsing::Duration& _internal_cache_duration() const;
+  ::mozilla::safebrowsing::Duration* _internal_mutable_cache_duration();
+  public:
+  void unsafe_arena_set_allocated_cache_duration(
+      ::mozilla::safebrowsing::Duration* cache_duration);
+  ::mozilla::safebrowsing::Duration* unsafe_arena_release_cache_duration();
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  bool has_threat_type() const;
+  private:
+  bool _internal_has_threat_type() const;
+  public:
+  void clear_threat_type();
+  ::mozilla::safebrowsing::ThreatType threat_type() const;
+  void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  private:
+  ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
+  void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  public:
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  bool has_platform_type() const;
+  private:
+  bool _internal_has_platform_type() const;
+  public:
+  void clear_platform_type();
+  ::mozilla::safebrowsing::PlatformType platform_type() const;
+  void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  private:
+  ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
+  void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  public:
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+  bool has_threat_entry_type() const;
+  private:
+  bool _internal_has_threat_entry_type() const;
+  public:
+  void clear_threat_entry_type();
+  ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  private:
+  ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
+  void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatMatch)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::mozilla::safebrowsing::ThreatEntry* threat_;
+    ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata_;
+    ::mozilla::safebrowsing::Duration* cache_duration_;
+    int threat_type_;
+    int platform_type_;
+    int threat_entry_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FindThreatMatchesRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindThreatMatchesRequest) */ {
+ public:
+  inline FindThreatMatchesRequest() : FindThreatMatchesRequest(nullptr) {}
+  ~FindThreatMatchesRequest() override;
+  explicit PROTOBUF_CONSTEXPR FindThreatMatchesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FindThreatMatchesRequest(const FindThreatMatchesRequest& from);
+  FindThreatMatchesRequest(FindThreatMatchesRequest&& from) noexcept
+    : FindThreatMatchesRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline FindThreatMatchesRequest& operator=(const FindThreatMatchesRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FindThreatMatchesRequest& operator=(FindThreatMatchesRequest&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FindThreatMatchesRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FindThreatMatchesRequest* internal_default_instance() {
+    return reinterpret_cast<const FindThreatMatchesRequest*>(
+               &_FindThreatMatchesRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(FindThreatMatchesRequest& a, FindThreatMatchesRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FindThreatMatchesRequest* 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(FindThreatMatchesRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FindThreatMatchesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FindThreatMatchesRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FindThreatMatchesRequest& from);
+  void MergeFrom(const FindThreatMatchesRequest& 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(FindThreatMatchesRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FindThreatMatchesRequest";
+  }
+  protected:
+  explicit FindThreatMatchesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientFieldNumber = 1,
+    kThreatInfoFieldNumber = 2,
+  };
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  bool has_client() const;
+  private:
+  bool _internal_has_client() const;
+  public:
+  void clear_client();
+  const ::mozilla::safebrowsing::ClientInfo& client() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client();
+  ::mozilla::safebrowsing::ClientInfo* mutable_client();
+  void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
+  private:
+  const ::mozilla::safebrowsing::ClientInfo& _internal_client() const;
+  ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client();
+  public:
+  void unsafe_arena_set_allocated_client(
+      ::mozilla::safebrowsing::ClientInfo* client);
+  ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client();
+
+  // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+  bool has_threat_info() const;
+  private:
+  bool _internal_has_threat_info() const;
+  public:
+  void clear_threat_info();
+  const ::mozilla::safebrowsing::ThreatInfo& threat_info() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatInfo* release_threat_info();
+  ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info();
+  void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info);
+  private:
+  const ::mozilla::safebrowsing::ThreatInfo& _internal_threat_info() const;
+  ::mozilla::safebrowsing::ThreatInfo* _internal_mutable_threat_info();
+  public:
+  void unsafe_arena_set_allocated_threat_info(
+      ::mozilla::safebrowsing::ThreatInfo* threat_info);
+  ::mozilla::safebrowsing::ThreatInfo* unsafe_arena_release_threat_info();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesRequest)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::mozilla::safebrowsing::ClientInfo* client_;
+    ::mozilla::safebrowsing::ThreatInfo* threat_info_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FindThreatMatchesResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindThreatMatchesResponse) */ {
+ public:
+  inline FindThreatMatchesResponse() : FindThreatMatchesResponse(nullptr) {}
+  ~FindThreatMatchesResponse() override;
+  explicit PROTOBUF_CONSTEXPR FindThreatMatchesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FindThreatMatchesResponse(const FindThreatMatchesResponse& from);
+  FindThreatMatchesResponse(FindThreatMatchesResponse&& from) noexcept
+    : FindThreatMatchesResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline FindThreatMatchesResponse& operator=(const FindThreatMatchesResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FindThreatMatchesResponse& operator=(FindThreatMatchesResponse&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FindThreatMatchesResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FindThreatMatchesResponse* internal_default_instance() {
+    return reinterpret_cast<const FindThreatMatchesResponse*>(
+               &_FindThreatMatchesResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(FindThreatMatchesResponse& a, FindThreatMatchesResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FindThreatMatchesResponse* 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(FindThreatMatchesResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FindThreatMatchesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FindThreatMatchesResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FindThreatMatchesResponse& from);
+  void MergeFrom(const FindThreatMatchesResponse& 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(FindThreatMatchesResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FindThreatMatchesResponse";
+  }
+  protected:
+  explicit FindThreatMatchesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMatchesFieldNumber = 1,
+  };
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  int matches_size() const;
+  private:
+  int _internal_matches_size() const;
+  public:
+  void clear_matches();
+  ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+      mutable_matches();
+  private:
+  const ::mozilla::safebrowsing::ThreatMatch& _internal_matches(int index) const;
+  ::mozilla::safebrowsing::ThreatMatch* _internal_add_matches();
+  public:
+  const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const;
+  ::mozilla::safebrowsing::ThreatMatch* add_matches();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+      matches() const;
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesResponse)
+ 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::ThreatMatch > matches_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints) */ {
+ public:
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() : FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(nullptr) {}
+  ~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() override;
+  explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&& from) noexcept
+    : FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() {
+    *this = ::std::move(from);
+  }
+
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* internal_default_instance() {
+    return reinterpret_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(
+               &_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& a, FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* 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(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
+  void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& 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(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints";
+  }
+  protected:
+  explicit FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSupportedCompressionsFieldNumber = 4,
+    kRegionFieldNumber = 3,
+    kMaxUpdateEntriesFieldNumber = 1,
+    kMaxDatabaseEntriesFieldNumber = 2,
+  };
+  // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+  int supported_compressions_size() const;
+  private:
+  int _internal_supported_compressions_size() const;
+  public:
+  void clear_supported_compressions();
+  private:
+  ::mozilla::safebrowsing::CompressionType _internal_supported_compressions(int index) const;
+  void _internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_compressions();
+  public:
+  ::mozilla::safebrowsing::CompressionType supported_compressions(int index) const;
+  void set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value);
+  void add_supported_compressions(::mozilla::safebrowsing::CompressionType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_compressions() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_compressions();
+
+  // optional string region = 3;
+  bool has_region() const;
+  private:
+  bool _internal_has_region() const;
+  public:
+  void clear_region();
+  const std::string& region() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_region(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_region();
+  PROTOBUF_NODISCARD std::string* release_region();
+  void set_allocated_region(std::string* region);
+  private:
+  const std::string& _internal_region() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_region(const std::string& value);
+  std::string* _internal_mutable_region();
+  public:
+
+  // optional int32 max_update_entries = 1;
+  bool has_max_update_entries() const;
+  private:
+  bool _internal_has_max_update_entries() const;
+  public:
+  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:
+
+  // optional int32 max_database_entries = 2;
+  bool has_max_database_entries() const;
+  private:
+  bool _internal_has_max_database_entries() const;
+  public:
+  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.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_compressions_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr region_;
+    int32_t max_update_entries_;
+    int32_t max_database_entries_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesRequest_ListUpdateRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest) */ {
+ public:
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest() : FetchThreatListUpdatesRequest_ListUpdateRequest(nullptr) {}
+  ~FetchThreatListUpdatesRequest_ListUpdateRequest() override;
+  explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest_ListUpdateRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
+  FetchThreatListUpdatesRequest_ListUpdateRequest(FetchThreatListUpdatesRequest_ListUpdateRequest&& from) noexcept
+    : FetchThreatListUpdatesRequest_ListUpdateRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(FetchThreatListUpdatesRequest_ListUpdateRequest&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FetchThreatListUpdatesRequest_ListUpdateRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FetchThreatListUpdatesRequest_ListUpdateRequest* internal_default_instance() {
+    return reinterpret_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>(
+               &_FetchThreatListUpdatesRequest_ListUpdateRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(FetchThreatListUpdatesRequest_ListUpdateRequest& a, FetchThreatListUpdatesRequest_ListUpdateRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* 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(FetchThreatListUpdatesRequest_ListUpdateRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FetchThreatListUpdatesRequest_ListUpdateRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
+  void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& 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(FetchThreatListUpdatesRequest_ListUpdateRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest";
+  }
+  protected:
+  explicit FetchThreatListUpdatesRequest_ListUpdateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints Constraints;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStateFieldNumber = 3,
+    kConstraintsFieldNumber = 4,
+    kThreatTypeFieldNumber = 1,
+    kPlatformTypeFieldNumber = 2,
+    kThreatEntryTypeFieldNumber = 5,
+  };
+  // optional bytes state = 3;
+  bool has_state() const;
+  private:
+  bool _internal_has_state() const;
+  public:
+  void clear_state();
+  const std::string& state() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_state(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_state();
+  PROTOBUF_NODISCARD std::string* release_state();
+  void set_allocated_state(std::string* state);
+  private:
+  const std::string& _internal_state() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_state(const std::string& value);
+  std::string* _internal_mutable_state();
+  public:
+
+  // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+  bool has_constraints() const;
+  private:
+  bool _internal_has_constraints() const;
+  public:
+  void clear_constraints();
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& constraints() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* release_constraints();
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* mutable_constraints();
+  void set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints);
+  private:
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& _internal_constraints() const;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* _internal_mutable_constraints();
+  public:
+  void unsafe_arena_set_allocated_constraints(
+      ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints);
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* unsafe_arena_release_constraints();
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  bool has_threat_type() const;
+  private:
+  bool _internal_has_threat_type() const;
+  public:
+  void clear_threat_type();
+  ::mozilla::safebrowsing::ThreatType threat_type() const;
+  void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  private:
+  ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
+  void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  public:
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  bool has_platform_type() const;
+  private:
+  bool _internal_has_platform_type() const;
+  public:
+  void clear_platform_type();
+  ::mozilla::safebrowsing::PlatformType platform_type() const;
+  void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  private:
+  ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
+  void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  public:
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+  bool has_threat_entry_type() const;
+  private:
+  bool _internal_has_threat_entry_type() const;
+  public:
+  void clear_threat_entry_type();
+  ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  private:
+  ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
+  void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr state_;
+    ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints_;
+    int threat_type_;
+    int platform_type_;
+    int threat_entry_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesRequest) */ {
+ public:
+  inline FetchThreatListUpdatesRequest() : FetchThreatListUpdatesRequest(nullptr) {}
+  ~FetchThreatListUpdatesRequest() override;
+  explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from);
+  FetchThreatListUpdatesRequest(FetchThreatListUpdatesRequest&& from) noexcept
+    : FetchThreatListUpdatesRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline FetchThreatListUpdatesRequest& operator=(const FetchThreatListUpdatesRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FetchThreatListUpdatesRequest& operator=(FetchThreatListUpdatesRequest&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FetchThreatListUpdatesRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FetchThreatListUpdatesRequest* internal_default_instance() {
+    return reinterpret_cast<const FetchThreatListUpdatesRequest*>(
+               &_FetchThreatListUpdatesRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(FetchThreatListUpdatesRequest& a, FetchThreatListUpdatesRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FetchThreatListUpdatesRequest* 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(FetchThreatListUpdatesRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FetchThreatListUpdatesRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FetchThreatListUpdatesRequest& from);
+  void MergeFrom(const FetchThreatListUpdatesRequest& 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(FetchThreatListUpdatesRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FetchThreatListUpdatesRequest";
+  }
+  protected:
+  explicit FetchThreatListUpdatesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesRequest_ListUpdateRequest ListUpdateRequest;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kListUpdateRequestsFieldNumber = 3,
+    kClientFieldNumber = 1,
+    kChromeClientInfoFieldNumber = 4,
+  };
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+  int list_update_requests_size() const;
+  private:
+  int _internal_list_update_requests_size() const;
+  public:
+  void clear_list_update_requests();
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* mutable_list_update_requests(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >*
+      mutable_list_update_requests();
+  private:
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& _internal_list_update_requests(int index) const;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* _internal_add_list_update_requests();
+  public:
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& list_update_requests(int index) const;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* add_list_update_requests();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >&
+      list_update_requests() const;
+
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  bool has_client() const;
+  private:
+  bool _internal_has_client() const;
+  public:
+  void clear_client();
+  const ::mozilla::safebrowsing::ClientInfo& client() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client();
+  ::mozilla::safebrowsing::ClientInfo* mutable_client();
+  void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
+  private:
+  const ::mozilla::safebrowsing::ClientInfo& _internal_client() const;
+  ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client();
+  public:
+  void unsafe_arena_set_allocated_client(
+      ::mozilla::safebrowsing::ClientInfo* client);
+  ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client();
+
+  // optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4;
+  bool has_chrome_client_info() const;
+  private:
+  bool _internal_has_chrome_client_info() const;
+  public:
+  void clear_chrome_client_info();
+  const ::mozilla::safebrowsing::ChromeClientInfo& chrome_client_info() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ChromeClientInfo* release_chrome_client_info();
+  ::mozilla::safebrowsing::ChromeClientInfo* mutable_chrome_client_info();
+  void set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info);
+  private:
+  const ::mozilla::safebrowsing::ChromeClientInfo& _internal_chrome_client_info() const;
+  ::mozilla::safebrowsing::ChromeClientInfo* _internal_mutable_chrome_client_info();
+  public:
+  void unsafe_arena_set_allocated_chrome_client_info(
+      ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info);
+  ::mozilla::safebrowsing::ChromeClientInfo* unsafe_arena_release_chrome_client_info();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest > list_update_requests_;
+    ::mozilla::safebrowsing::ClientInfo* client_;
+    ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesResponse_ListUpdateResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse) */ {
+ public:
+  inline FetchThreatListUpdatesResponse_ListUpdateResponse() : FetchThreatListUpdatesResponse_ListUpdateResponse(nullptr) {}
+  ~FetchThreatListUpdatesResponse_ListUpdateResponse() override;
+  explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse_ListUpdateResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
+  FetchThreatListUpdatesResponse_ListUpdateResponse(FetchThreatListUpdatesResponse_ListUpdateResponse&& from) noexcept
+    : FetchThreatListUpdatesResponse_ListUpdateResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(FetchThreatListUpdatesResponse_ListUpdateResponse&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FetchThreatListUpdatesResponse_ListUpdateResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FetchThreatListUpdatesResponse_ListUpdateResponse* internal_default_instance() {
+    return reinterpret_cast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>(
+               &_FetchThreatListUpdatesResponse_ListUpdateResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(FetchThreatListUpdatesResponse_ListUpdateResponse& a, FetchThreatListUpdatesResponse_ListUpdateResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* 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(FetchThreatListUpdatesResponse_ListUpdateResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesResponse_ListUpdateResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FetchThreatListUpdatesResponse_ListUpdateResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
+  void MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& 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(FetchThreatListUpdatesResponse_ListUpdateResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse";
+  }
+  protected:
+  explicit FetchThreatListUpdatesResponse_ListUpdateResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType ResponseType;
+  static constexpr ResponseType RESPONSE_TYPE_UNSPECIFIED =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED;
+  static constexpr ResponseType PARTIAL_UPDATE =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE;
+  static constexpr ResponseType FULL_UPDATE =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE;
+  static inline bool ResponseType_IsValid(int value) {
+    return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value);
+  }
+  static constexpr ResponseType ResponseType_MIN =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN;
+  static constexpr ResponseType ResponseType_MAX =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX;
+  static constexpr int ResponseType_ARRAYSIZE =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ResponseType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ResponseType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ResponseType_Name.");
+    return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Name(enum_t_value);
+  }
+  static inline bool ResponseType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ResponseType* value) {
+    return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAdditionsFieldNumber = 5,
+    kRemovalsFieldNumber = 6,
+    kNewClientStateFieldNumber = 7,
+    kChecksumFieldNumber = 8,
+    kThreatTypeFieldNumber = 1,
+    kThreatEntryTypeFieldNumber = 2,
+    kPlatformTypeFieldNumber = 3,
+    kResponseTypeFieldNumber = 4,
+  };
+  // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+  int additions_size() const;
+  private:
+  int _internal_additions_size() const;
+  public:
+  void clear_additions();
+  ::mozilla::safebrowsing::ThreatEntrySet* mutable_additions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+      mutable_additions();
+  private:
+  const ::mozilla::safebrowsing::ThreatEntrySet& _internal_additions(int index) const;
+  ::mozilla::safebrowsing::ThreatEntrySet* _internal_add_additions();
+  public:
+  const ::mozilla::safebrowsing::ThreatEntrySet& additions(int index) const;
+  ::mozilla::safebrowsing::ThreatEntrySet* add_additions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+      additions() const;
+
+  // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+  int removals_size() const;
+  private:
+  int _internal_removals_size() const;
+  public:
+  void clear_removals();
+  ::mozilla::safebrowsing::ThreatEntrySet* mutable_removals(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+      mutable_removals();
+  private:
+  const ::mozilla::safebrowsing::ThreatEntrySet& _internal_removals(int index) const;
+  ::mozilla::safebrowsing::ThreatEntrySet* _internal_add_removals();
+  public:
+  const ::mozilla::safebrowsing::ThreatEntrySet& removals(int index) const;
+  ::mozilla::safebrowsing::ThreatEntrySet* add_removals();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+      removals() const;
+
+  // optional bytes new_client_state = 7;
+  bool has_new_client_state() const;
+  private:
+  bool _internal_has_new_client_state() const;
+  public:
+  void clear_new_client_state();
+  const std::string& new_client_state() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_new_client_state(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_new_client_state();
+  PROTOBUF_NODISCARD std::string* release_new_client_state();
+  void set_allocated_new_client_state(std::string* new_client_state);
+  private:
+  const std::string& _internal_new_client_state() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_new_client_state(const std::string& value);
+  std::string* _internal_mutable_new_client_state();
+  public:
+
+  // optional .mozilla.safebrowsing.Checksum checksum = 8;
+  bool has_checksum() const;
+  private:
+  bool _internal_has_checksum() const;
+  public:
+  void clear_checksum();
+  const ::mozilla::safebrowsing::Checksum& checksum() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::Checksum* release_checksum();
+  ::mozilla::safebrowsing::Checksum* mutable_checksum();
+  void set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum);
+  private:
+  const ::mozilla::safebrowsing::Checksum& _internal_checksum() const;
+  ::mozilla::safebrowsing::Checksum* _internal_mutable_checksum();
+  public:
+  void unsafe_arena_set_allocated_checksum(
+      ::mozilla::safebrowsing::Checksum* checksum);
+  ::mozilla::safebrowsing::Checksum* unsafe_arena_release_checksum();
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  bool has_threat_type() const;
+  private:
+  bool _internal_has_threat_type() const;
+  public:
+  void clear_threat_type();
+  ::mozilla::safebrowsing::ThreatType threat_type() const;
+  void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  private:
+  ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
+  void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  public:
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+  bool has_threat_entry_type() const;
+  private:
+  bool _internal_has_threat_entry_type() const;
+  public:
+  void clear_threat_entry_type();
+  ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  private:
+  ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
+  void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  public:
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+  bool has_platform_type() const;
+  private:
+  bool _internal_has_platform_type() const;
+  public:
+  void clear_platform_type();
+  ::mozilla::safebrowsing::PlatformType platform_type() const;
+  void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  private:
+  ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
+  void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  public:
+
+  // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+  bool has_response_type() const;
+  private:
+  bool _internal_has_response_type() const;
+  public:
+  void clear_response_type();
+  ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType response_type() const;
+  void set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
+  private:
+  ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType _internal_response_type() const;
+  void _internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > additions_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > removals_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_client_state_;
+    ::mozilla::safebrowsing::Checksum* checksum_;
+    int threat_type_;
+    int threat_entry_type_;
+    int platform_type_;
+    int response_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FetchThreatListUpdatesResponse) */ {
+ public:
+  inline FetchThreatListUpdatesResponse() : FetchThreatListUpdatesResponse(nullptr) {}
+  ~FetchThreatListUpdatesResponse() override;
+  explicit PROTOBUF_CONSTEXPR FetchThreatListUpdatesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from);
+  FetchThreatListUpdatesResponse(FetchThreatListUpdatesResponse&& from) noexcept
+    : FetchThreatListUpdatesResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline FetchThreatListUpdatesResponse& operator=(const FetchThreatListUpdatesResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FetchThreatListUpdatesResponse& operator=(FetchThreatListUpdatesResponse&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FetchThreatListUpdatesResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FetchThreatListUpdatesResponse* internal_default_instance() {
+    return reinterpret_cast<const FetchThreatListUpdatesResponse*>(
+               &_FetchThreatListUpdatesResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(FetchThreatListUpdatesResponse& a, FetchThreatListUpdatesResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FetchThreatListUpdatesResponse* 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(FetchThreatListUpdatesResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FetchThreatListUpdatesResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FetchThreatListUpdatesResponse& from);
+  void MergeFrom(const FetchThreatListUpdatesResponse& 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(FetchThreatListUpdatesResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FetchThreatListUpdatesResponse";
+  }
+  protected:
+  explicit FetchThreatListUpdatesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesResponse_ListUpdateResponse ListUpdateResponse;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kListUpdateResponsesFieldNumber = 1,
+    kMinimumWaitDurationFieldNumber = 2,
+  };
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+  int list_update_responses_size() const;
+  private:
+  int _internal_list_update_responses_size() const;
+  public:
+  void clear_list_update_responses();
+  ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* mutable_list_update_responses(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >*
+      mutable_list_update_responses();
+  private:
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& _internal_list_update_responses(int index) const;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* _internal_add_list_update_responses();
+  public:
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& list_update_responses(int index) const;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* add_list_update_responses();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >&
+      list_update_responses() const;
+
+  // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+  bool has_minimum_wait_duration() const;
+  private:
+  bool _internal_has_minimum_wait_duration() const;
+  public:
+  void clear_minimum_wait_duration();
+  const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_minimum_wait_duration();
+  ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration();
+  void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration);
+  private:
+  const ::mozilla::safebrowsing::Duration& _internal_minimum_wait_duration() const;
+  ::mozilla::safebrowsing::Duration* _internal_mutable_minimum_wait_duration();
+  public:
+  void unsafe_arena_set_allocated_minimum_wait_duration(
+      ::mozilla::safebrowsing::Duration* minimum_wait_duration);
+  ::mozilla::safebrowsing::Duration* unsafe_arena_release_minimum_wait_duration();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse > list_update_responses_;
+    ::mozilla::safebrowsing::Duration* minimum_wait_duration_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FindFullHashesRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindFullHashesRequest) */ {
+ public:
+  inline FindFullHashesRequest() : FindFullHashesRequest(nullptr) {}
+  ~FindFullHashesRequest() override;
+  explicit PROTOBUF_CONSTEXPR FindFullHashesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FindFullHashesRequest(const FindFullHashesRequest& from);
+  FindFullHashesRequest(FindFullHashesRequest&& from) noexcept
+    : FindFullHashesRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline FindFullHashesRequest& operator=(const FindFullHashesRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FindFullHashesRequest& operator=(FindFullHashesRequest&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FindFullHashesRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FindFullHashesRequest* internal_default_instance() {
+    return reinterpret_cast<const FindFullHashesRequest*>(
+               &_FindFullHashesRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(FindFullHashesRequest& a, FindFullHashesRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FindFullHashesRequest* 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(FindFullHashesRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FindFullHashesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FindFullHashesRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FindFullHashesRequest& from);
+  void MergeFrom(const FindFullHashesRequest& 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(FindFullHashesRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FindFullHashesRequest";
+  }
+  protected:
+  explicit FindFullHashesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientStatesFieldNumber = 2,
+    kClientFieldNumber = 1,
+    kThreatInfoFieldNumber = 3,
+  };
+  // repeated bytes client_states = 2;
+  int client_states_size() const;
+  private:
+  int _internal_client_states_size() const;
+  public:
+  void clear_client_states();
+  const std::string& client_states(int index) const;
+  std::string* mutable_client_states(int index);
+  void set_client_states(int index, const std::string& value);
+  void set_client_states(int index, std::string&& value);
+  void set_client_states(int index, const char* value);
+  void set_client_states(int index, const void* value, size_t size);
+  std::string* add_client_states();
+  void add_client_states(const std::string& value);
+  void add_client_states(std::string&& value);
+  void add_client_states(const char* value);
+  void add_client_states(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& client_states() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_client_states();
+  private:
+  const std::string& _internal_client_states(int index) const;
+  std::string* _internal_add_client_states();
+  public:
+
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  bool has_client() const;
+  private:
+  bool _internal_has_client() const;
+  public:
+  void clear_client();
+  const ::mozilla::safebrowsing::ClientInfo& client() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client();
+  ::mozilla::safebrowsing::ClientInfo* mutable_client();
+  void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
+  private:
+  const ::mozilla::safebrowsing::ClientInfo& _internal_client() const;
+  ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client();
+  public:
+  void unsafe_arena_set_allocated_client(
+      ::mozilla::safebrowsing::ClientInfo* client);
+  ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client();
+
+  // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+  bool has_threat_info() const;
+  private:
+  bool _internal_has_threat_info() const;
+  public:
+  void clear_threat_info();
+  const ::mozilla::safebrowsing::ThreatInfo& threat_info() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatInfo* release_threat_info();
+  ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info();
+  void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info);
+  private:
+  const ::mozilla::safebrowsing::ThreatInfo& _internal_threat_info() const;
+  ::mozilla::safebrowsing::ThreatInfo* _internal_mutable_threat_info();
+  public:
+  void unsafe_arena_set_allocated_threat_info(
+      ::mozilla::safebrowsing::ThreatInfo* threat_info);
+  ::mozilla::safebrowsing::ThreatInfo* unsafe_arena_release_threat_info();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesRequest)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> client_states_;
+    ::mozilla::safebrowsing::ClientInfo* client_;
+    ::mozilla::safebrowsing::ThreatInfo* threat_info_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FindFullHashesResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.FindFullHashesResponse) */ {
+ public:
+  inline FindFullHashesResponse() : FindFullHashesResponse(nullptr) {}
+  ~FindFullHashesResponse() override;
+  explicit PROTOBUF_CONSTEXPR FindFullHashesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FindFullHashesResponse(const FindFullHashesResponse& from);
+  FindFullHashesResponse(FindFullHashesResponse&& from) noexcept
+    : FindFullHashesResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline FindFullHashesResponse& operator=(const FindFullHashesResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FindFullHashesResponse& operator=(FindFullHashesResponse&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const FindFullHashesResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FindFullHashesResponse* internal_default_instance() {
+    return reinterpret_cast<const FindFullHashesResponse*>(
+               &_FindFullHashesResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(FindFullHashesResponse& a, FindFullHashesResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FindFullHashesResponse* 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(FindFullHashesResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FindFullHashesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FindFullHashesResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const FindFullHashesResponse& from);
+  void MergeFrom(const FindFullHashesResponse& 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(FindFullHashesResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.FindFullHashesResponse";
+  }
+  protected:
+  explicit FindFullHashesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMatchesFieldNumber = 1,
+    kMinimumWaitDurationFieldNumber = 2,
+    kNegativeCacheDurationFieldNumber = 3,
+  };
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  int matches_size() const;
+  private:
+  int _internal_matches_size() const;
+  public:
+  void clear_matches();
+  ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+      mutable_matches();
+  private:
+  const ::mozilla::safebrowsing::ThreatMatch& _internal_matches(int index) const;
+  ::mozilla::safebrowsing::ThreatMatch* _internal_add_matches();
+  public:
+  const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const;
+  ::mozilla::safebrowsing::ThreatMatch* add_matches();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+      matches() const;
+
+  // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+  bool has_minimum_wait_duration() const;
+  private:
+  bool _internal_has_minimum_wait_duration() const;
+  public:
+  void clear_minimum_wait_duration();
+  const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_minimum_wait_duration();
+  ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration();
+  void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration);
+  private:
+  const ::mozilla::safebrowsing::Duration& _internal_minimum_wait_duration() const;
+  ::mozilla::safebrowsing::Duration* _internal_mutable_minimum_wait_duration();
+  public:
+  void unsafe_arena_set_allocated_minimum_wait_duration(
+      ::mozilla::safebrowsing::Duration* minimum_wait_duration);
+  ::mozilla::safebrowsing::Duration* unsafe_arena_release_minimum_wait_duration();
+
+  // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+  bool has_negative_cache_duration() const;
+  private:
+  bool _internal_has_negative_cache_duration() const;
+  public:
+  void clear_negative_cache_duration();
+  const ::mozilla::safebrowsing::Duration& negative_cache_duration() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::Duration* release_negative_cache_duration();
+  ::mozilla::safebrowsing::Duration* mutable_negative_cache_duration();
+  void set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration);
+  private:
+  const ::mozilla::safebrowsing::Duration& _internal_negative_cache_duration() const;
+  ::mozilla::safebrowsing::Duration* _internal_mutable_negative_cache_duration();
+  public:
+  void unsafe_arena_set_allocated_negative_cache_duration(
+      ::mozilla::safebrowsing::Duration* negative_cache_duration);
+  ::mozilla::safebrowsing::Duration* unsafe_arena_release_negative_cache_duration();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesResponse)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_;
+    ::mozilla::safebrowsing::Duration* minimum_wait_duration_;
+    ::mozilla::safebrowsing::Duration* negative_cache_duration_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatHit_ThreatSource final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit.ThreatSource) */ {
+ public:
+  inline ThreatHit_ThreatSource() : ThreatHit_ThreatSource(nullptr) {}
+  ~ThreatHit_ThreatSource() override;
+  explicit PROTOBUF_CONSTEXPR ThreatHit_ThreatSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from);
+  ThreatHit_ThreatSource(ThreatHit_ThreatSource&& from) noexcept
+    : ThreatHit_ThreatSource() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatHit_ThreatSource& operator=(const ThreatHit_ThreatSource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatHit_ThreatSource& operator=(ThreatHit_ThreatSource&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatHit_ThreatSource& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatHit_ThreatSource* internal_default_instance() {
+    return reinterpret_cast<const ThreatHit_ThreatSource*>(
+               &_ThreatHit_ThreatSource_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ThreatHit_ThreatSource& a, ThreatHit_ThreatSource& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatHit_ThreatSource* 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(ThreatHit_ThreatSource* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatHit_ThreatSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatHit_ThreatSource>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatHit_ThreatSource& from);
+  void MergeFrom(const ThreatHit_ThreatSource& 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(ThreatHit_ThreatSource* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatHit.ThreatSource";
+  }
+  protected:
+  explicit ThreatHit_ThreatSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kRemoteIpFieldNumber = 3,
+    kReferrerFieldNumber = 4,
+    kTypeFieldNumber = 2,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string remote_ip = 3;
+  bool has_remote_ip() const;
+  private:
+  bool _internal_has_remote_ip() const;
+  public:
+  void clear_remote_ip();
+  const std::string& remote_ip() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_remote_ip(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_remote_ip();
+  PROTOBUF_NODISCARD std::string* release_remote_ip();
+  void set_allocated_remote_ip(std::string* remote_ip);
+  private:
+  const std::string& _internal_remote_ip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_ip(const std::string& value);
+  std::string* _internal_mutable_remote_ip();
+  public:
+
+  // optional string referrer = 4;
+  bool has_referrer() const;
+  private:
+  bool _internal_has_referrer() const;
+  public:
+  void clear_referrer();
+  const std::string& referrer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer();
+  PROTOBUF_NODISCARD std::string* release_referrer();
+  void set_allocated_referrer(std::string* referrer);
+  private:
+  const std::string& _internal_referrer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer(const std::string& value);
+  std::string* _internal_mutable_referrer();
+  public:
+
+  // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::mozilla::safebrowsing::ThreatHit_ThreatSourceType type() const;
+  void set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value);
+  private:
+  ::mozilla::safebrowsing::ThreatHit_ThreatSourceType _internal_type() const;
+  void _internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.ThreatSource)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_ip_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatHit_UserInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit.UserInfo) */ {
+ public:
+  inline ThreatHit_UserInfo() : ThreatHit_UserInfo(nullptr) {}
+  ~ThreatHit_UserInfo() override;
+  explicit PROTOBUF_CONSTEXPR ThreatHit_UserInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatHit_UserInfo(const ThreatHit_UserInfo& from);
+  ThreatHit_UserInfo(ThreatHit_UserInfo&& from) noexcept
+    : ThreatHit_UserInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatHit_UserInfo& operator=(const ThreatHit_UserInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatHit_UserInfo& operator=(ThreatHit_UserInfo&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatHit_UserInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatHit_UserInfo* internal_default_instance() {
+    return reinterpret_cast<const ThreatHit_UserInfo*>(
+               &_ThreatHit_UserInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(ThreatHit_UserInfo& a, ThreatHit_UserInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatHit_UserInfo* 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(ThreatHit_UserInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatHit_UserInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatHit_UserInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatHit_UserInfo& from);
+  void MergeFrom(const ThreatHit_UserInfo& 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(ThreatHit_UserInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatHit.UserInfo";
+  }
+  protected:
+  explicit ThreatHit_UserInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRegionCodeFieldNumber = 1,
+    kUserIdFieldNumber = 2,
+  };
+  // optional string region_code = 1;
+  bool has_region_code() const;
+  private:
+  bool _internal_has_region_code() const;
+  public:
+  void clear_region_code();
+  const std::string& region_code() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_region_code(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_region_code();
+  PROTOBUF_NODISCARD std::string* release_region_code();
+  void set_allocated_region_code(std::string* region_code);
+  private:
+  const std::string& _internal_region_code() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_region_code(const std::string& value);
+  std::string* _internal_mutable_region_code();
+  public:
+
+  // optional bytes user_id = 2;
+  bool has_user_id() const;
+  private:
+  bool _internal_has_user_id() const;
+  public:
+  void clear_user_id();
+  const std::string& user_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_user_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_user_id();
+  PROTOBUF_NODISCARD std::string* release_user_id();
+  void set_allocated_user_id(std::string* user_id);
+  private:
+  const std::string& _internal_user_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_user_id(const std::string& value);
+  std::string* _internal_mutable_user_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.UserInfo)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr region_code_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr user_id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatHit final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatHit) */ {
+ public:
+  inline ThreatHit() : ThreatHit(nullptr) {}
+  ~ThreatHit() override;
+  explicit PROTOBUF_CONSTEXPR ThreatHit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatHit(const ThreatHit& from);
+  ThreatHit(ThreatHit&& from) noexcept
+    : ThreatHit() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatHit& operator=(const ThreatHit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatHit& operator=(ThreatHit&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatHit& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatHit* internal_default_instance() {
+    return reinterpret_cast<const ThreatHit*>(
+               &_ThreatHit_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(ThreatHit& a, ThreatHit& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatHit* 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(ThreatHit* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatHit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatHit>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatHit& from);
+  void MergeFrom(const ThreatHit& 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(ThreatHit* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatHit";
+  }
+  protected:
+  explicit ThreatHit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ThreatHit_ThreatSource ThreatSource;
+  typedef ThreatHit_UserInfo UserInfo;
+
+  typedef ThreatHit_ThreatSourceType ThreatSourceType;
+  static constexpr ThreatSourceType THREAT_SOURCE_TYPE_UNSPECIFIED =
+    ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED;
+  static constexpr ThreatSourceType MATCHING_URL =
+    ThreatHit_ThreatSourceType_MATCHING_URL;
+  static constexpr ThreatSourceType TAB_URL =
+    ThreatHit_ThreatSourceType_TAB_URL;
+  static constexpr ThreatSourceType TAB_REDIRECT =
+    ThreatHit_ThreatSourceType_TAB_REDIRECT;
+  static constexpr ThreatSourceType TAB_RESOURCE =
+    ThreatHit_ThreatSourceType_TAB_RESOURCE;
+  static inline bool ThreatSourceType_IsValid(int value) {
+    return ThreatHit_ThreatSourceType_IsValid(value);
+  }
+  static constexpr ThreatSourceType ThreatSourceType_MIN =
+    ThreatHit_ThreatSourceType_ThreatSourceType_MIN;
+  static constexpr ThreatSourceType ThreatSourceType_MAX =
+    ThreatHit_ThreatSourceType_ThreatSourceType_MAX;
+  static constexpr int ThreatSourceType_ARRAYSIZE =
+    ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ThreatSourceType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ThreatSourceType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ThreatSourceType_Name.");
+    return ThreatHit_ThreatSourceType_Name(enum_t_value);
+  }
+  static inline bool ThreatSourceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ThreatSourceType* value) {
+    return ThreatHit_ThreatSourceType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kResourcesFieldNumber = 4,
+    kEntryFieldNumber = 3,
+    kClientInfoFieldNumber = 5,
+    kUserInfoFieldNumber = 6,
+    kThreatTypeFieldNumber = 1,
+    kPlatformTypeFieldNumber = 2,
+  };
+  // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+  int resources_size() const;
+  private:
+  int _internal_resources_size() const;
+  public:
+  void clear_resources();
+  ::mozilla::safebrowsing::ThreatHit_ThreatSource* mutable_resources(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >*
+      mutable_resources();
+  private:
+  const ::mozilla::safebrowsing::ThreatHit_ThreatSource& _internal_resources(int index) const;
+  ::mozilla::safebrowsing::ThreatHit_ThreatSource* _internal_add_resources();
+  public:
+  const ::mozilla::safebrowsing::ThreatHit_ThreatSource& resources(int index) const;
+  ::mozilla::safebrowsing::ThreatHit_ThreatSource* add_resources();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >&
+      resources() const;
+
+  // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+  bool has_entry() const;
+  private:
+  bool _internal_has_entry() const;
+  public:
+  void clear_entry();
+  const ::mozilla::safebrowsing::ThreatEntry& entry() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatEntry* release_entry();
+  ::mozilla::safebrowsing::ThreatEntry* mutable_entry();
+  void set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry);
+  private:
+  const ::mozilla::safebrowsing::ThreatEntry& _internal_entry() const;
+  ::mozilla::safebrowsing::ThreatEntry* _internal_mutable_entry();
+  public:
+  void unsafe_arena_set_allocated_entry(
+      ::mozilla::safebrowsing::ThreatEntry* entry);
+  ::mozilla::safebrowsing::ThreatEntry* unsafe_arena_release_entry();
+
+  // optional .mozilla.safebrowsing.ClientInfo client_info = 5;
+  bool has_client_info() const;
+  private:
+  bool _internal_has_client_info() const;
+  public:
+  void clear_client_info();
+  const ::mozilla::safebrowsing::ClientInfo& client_info() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ClientInfo* release_client_info();
+  ::mozilla::safebrowsing::ClientInfo* mutable_client_info();
+  void set_allocated_client_info(::mozilla::safebrowsing::ClientInfo* client_info);
+  private:
+  const ::mozilla::safebrowsing::ClientInfo& _internal_client_info() const;
+  ::mozilla::safebrowsing::ClientInfo* _internal_mutable_client_info();
+  public:
+  void unsafe_arena_set_allocated_client_info(
+      ::mozilla::safebrowsing::ClientInfo* client_info);
+  ::mozilla::safebrowsing::ClientInfo* unsafe_arena_release_client_info();
+
+  // optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6;
+  bool has_user_info() const;
+  private:
+  bool _internal_has_user_info() const;
+  public:
+  void clear_user_info();
+  const ::mozilla::safebrowsing::ThreatHit_UserInfo& user_info() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::ThreatHit_UserInfo* release_user_info();
+  ::mozilla::safebrowsing::ThreatHit_UserInfo* mutable_user_info();
+  void set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo* user_info);
+  private:
+  const ::mozilla::safebrowsing::ThreatHit_UserInfo& _internal_user_info() const;
+  ::mozilla::safebrowsing::ThreatHit_UserInfo* _internal_mutable_user_info();
+  public:
+  void unsafe_arena_set_allocated_user_info(
+      ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info);
+  ::mozilla::safebrowsing::ThreatHit_UserInfo* unsafe_arena_release_user_info();
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  bool has_threat_type() const;
+  private:
+  bool _internal_has_threat_type() const;
+  public:
+  void clear_threat_type();
+  ::mozilla::safebrowsing::ThreatType threat_type() const;
+  void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  private:
+  ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
+  void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  public:
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  bool has_platform_type() const;
+  private:
+  bool _internal_has_platform_type() const;
+  public:
+  void clear_platform_type();
+  ::mozilla::safebrowsing::PlatformType platform_type() const;
+  void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  private:
+  ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
+  void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource > resources_;
+    ::mozilla::safebrowsing::ThreatEntry* entry_;
+    ::mozilla::safebrowsing::ClientInfo* client_info_;
+    ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info_;
+    int threat_type_;
+    int platform_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ClientInfo) */ {
+ public:
+  inline ClientInfo() : ClientInfo(nullptr) {}
+  ~ClientInfo() override;
+  explicit PROTOBUF_CONSTEXPR ClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientInfo(const ClientInfo& from);
+  ClientInfo(ClientInfo&& from) noexcept
+    : ClientInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientInfo& operator=(const ClientInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientInfo& operator=(ClientInfo&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientInfo* internal_default_instance() {
+    return reinterpret_cast<const ClientInfo*>(
+               &_ClientInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(ClientInfo& a, ClientInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientInfo* 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(ClientInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientInfo& from);
+  void MergeFrom(const ClientInfo& 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(ClientInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ClientInfo";
+  }
+  protected:
+  explicit ClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientIdFieldNumber = 1,
+    kClientVersionFieldNumber = 2,
+  };
+  // optional string client_id = 1;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const std::string& client_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_id();
+  PROTOBUF_NODISCARD std::string* release_client_id();
+  void set_allocated_client_id(std::string* client_id);
+  private:
+  const std::string& _internal_client_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_id(const std::string& value);
+  std::string* _internal_mutable_client_id();
+  public:
+
+  // optional string client_version = 2;
+  bool has_client_version() const;
+  private:
+  bool _internal_has_client_version() const;
+  public:
+  void clear_client_version();
+  const std::string& client_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_version();
+  PROTOBUF_NODISCARD std::string* release_client_version();
+  void set_allocated_client_version(std::string* client_version);
+  private:
+  const std::string& _internal_client_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_version(const std::string& value);
+  std::string* _internal_mutable_client_version();
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ClientInfo)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ChromeClientInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ChromeClientInfo) */ {
+ public:
+  inline ChromeClientInfo() : ChromeClientInfo(nullptr) {}
+  ~ChromeClientInfo() override;
+  explicit PROTOBUF_CONSTEXPR ChromeClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ChromeClientInfo(const ChromeClientInfo& from);
+  ChromeClientInfo(ChromeClientInfo&& from) noexcept
+    : ChromeClientInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ChromeClientInfo& operator=(const ChromeClientInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ChromeClientInfo& operator=(ChromeClientInfo&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ChromeClientInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ChromeClientInfo* internal_default_instance() {
+    return reinterpret_cast<const ChromeClientInfo*>(
+               &_ChromeClientInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(ChromeClientInfo& a, ChromeClientInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ChromeClientInfo* 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(ChromeClientInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ChromeClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ChromeClientInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ChromeClientInfo& from);
+  void MergeFrom(const ChromeClientInfo& 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(ChromeClientInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ChromeClientInfo";
+  }
+  protected:
+  explicit ChromeClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ChromeClientInfo_SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation;
+  static constexpr SafeBrowsingReportingPopulation UNSPECIFIED =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_UNSPECIFIED;
+  static constexpr SafeBrowsingReportingPopulation OPT_OUT =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_OPT_OUT;
+  static constexpr SafeBrowsingReportingPopulation EXTENDED =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_EXTENDED;
+  static constexpr SafeBrowsingReportingPopulation SCOUT =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_SCOUT;
+  static inline bool SafeBrowsingReportingPopulation_IsValid(int value) {
+    return ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(value);
+  }
+  static constexpr SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation_MIN =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MIN;
+  static constexpr SafeBrowsingReportingPopulation SafeBrowsingReportingPopulation_MAX =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_MAX;
+  static constexpr int SafeBrowsingReportingPopulation_ARRAYSIZE =
+    ChromeClientInfo_SafeBrowsingReportingPopulation_SafeBrowsingReportingPopulation_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& SafeBrowsingReportingPopulation_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SafeBrowsingReportingPopulation>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SafeBrowsingReportingPopulation_Name.");
+    return ChromeClientInfo_SafeBrowsingReportingPopulation_Name(enum_t_value);
+  }
+  static inline bool SafeBrowsingReportingPopulation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SafeBrowsingReportingPopulation* value) {
+    return ChromeClientInfo_SafeBrowsingReportingPopulation_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReportingPopulationFieldNumber = 1,
+  };
+  // optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1;
+  bool has_reporting_population() const;
+  private:
+  bool _internal_has_reporting_population() const;
+  public:
+  void clear_reporting_population();
+  ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation reporting_population() const;
+  void set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value);
+  private:
+  ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation _internal_reporting_population() const;
+  void _internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ChromeClientInfo)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int reporting_population_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Checksum final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.Checksum) */ {
+ public:
+  inline Checksum() : Checksum(nullptr) {}
+  ~Checksum() override;
+  explicit PROTOBUF_CONSTEXPR Checksum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Checksum(const Checksum& from);
+  Checksum(Checksum&& from) noexcept
+    : Checksum() {
+    *this = ::std::move(from);
+  }
+
+  inline Checksum& operator=(const Checksum& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Checksum& operator=(Checksum&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const Checksum& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Checksum* internal_default_instance() {
+    return reinterpret_cast<const Checksum*>(
+               &_Checksum_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(Checksum& a, Checksum& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Checksum* 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(Checksum* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Checksum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Checksum>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const Checksum& from);
+  void MergeFrom(const Checksum& 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(Checksum* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.Checksum";
+  }
+  protected:
+  explicit Checksum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSha256FieldNumber = 1,
+  };
+  // optional bytes sha256 = 1;
+  bool has_sha256() const;
+  private:
+  bool _internal_has_sha256() const;
+  public:
+  void clear_sha256();
+  const std::string& sha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sha256();
+  PROTOBUF_NODISCARD std::string* release_sha256();
+  void set_allocated_sha256(std::string* sha256);
+  private:
+  const std::string& _internal_sha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sha256(const std::string& value);
+  std::string* _internal_mutable_sha256();
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Checksum)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha256_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntry) */ {
+ public:
+  inline ThreatEntry() : ThreatEntry(nullptr) {}
+  ~ThreatEntry() override;
+  explicit PROTOBUF_CONSTEXPR ThreatEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatEntry(const ThreatEntry& from);
+  ThreatEntry(ThreatEntry&& from) noexcept
+    : ThreatEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatEntry& operator=(const ThreatEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatEntry& operator=(ThreatEntry&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatEntry* internal_default_instance() {
+    return reinterpret_cast<const ThreatEntry*>(
+               &_ThreatEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(ThreatEntry& a, ThreatEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatEntry* 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(ThreatEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatEntry>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatEntry& from);
+  void MergeFrom(const ThreatEntry& 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(ThreatEntry* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatEntry";
+  }
+  protected:
+  explicit ThreatEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHashFieldNumber = 1,
+    kUrlFieldNumber = 2,
+  };
+  // optional bytes hash = 1;
+  bool has_hash() const;
+  private:
+  bool _internal_has_hash() const;
+  public:
+  void clear_hash();
+  const std::string& hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hash();
+  PROTOBUF_NODISCARD std::string* release_hash();
+  void set_allocated_hash(std::string* hash);
+  private:
+  const std::string& _internal_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
+  std::string* _internal_mutable_hash();
+  public:
+
+  // optional string url = 2;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntry)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntrySet final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntrySet) */ {
+ public:
+  inline ThreatEntrySet() : ThreatEntrySet(nullptr) {}
+  ~ThreatEntrySet() override;
+  explicit PROTOBUF_CONSTEXPR ThreatEntrySet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatEntrySet(const ThreatEntrySet& from);
+  ThreatEntrySet(ThreatEntrySet&& from) noexcept
+    : ThreatEntrySet() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatEntrySet& operator=(const ThreatEntrySet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatEntrySet& operator=(ThreatEntrySet&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatEntrySet& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatEntrySet* internal_default_instance() {
+    return reinterpret_cast<const ThreatEntrySet*>(
+               &_ThreatEntrySet_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(ThreatEntrySet& a, ThreatEntrySet& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatEntrySet* 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(ThreatEntrySet* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntrySet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatEntrySet>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatEntrySet& from);
+  void MergeFrom(const ThreatEntrySet& 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(ThreatEntrySet* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatEntrySet";
+  }
+  protected:
+  explicit ThreatEntrySet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRawHashesFieldNumber = 2,
+    kRawIndicesFieldNumber = 3,
+    kRiceHashesFieldNumber = 4,
+    kRiceIndicesFieldNumber = 5,
+    kCompressionTypeFieldNumber = 1,
+  };
+  // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+  bool has_raw_hashes() const;
+  private:
+  bool _internal_has_raw_hashes() const;
+  public:
+  void clear_raw_hashes();
+  const ::mozilla::safebrowsing::RawHashes& raw_hashes() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::RawHashes* release_raw_hashes();
+  ::mozilla::safebrowsing::RawHashes* mutable_raw_hashes();
+  void set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes);
+  private:
+  const ::mozilla::safebrowsing::RawHashes& _internal_raw_hashes() const;
+  ::mozilla::safebrowsing::RawHashes* _internal_mutable_raw_hashes();
+  public:
+  void unsafe_arena_set_allocated_raw_hashes(
+      ::mozilla::safebrowsing::RawHashes* raw_hashes);
+  ::mozilla::safebrowsing::RawHashes* unsafe_arena_release_raw_hashes();
+
+  // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+  bool has_raw_indices() const;
+  private:
+  bool _internal_has_raw_indices() const;
+  public:
+  void clear_raw_indices();
+  const ::mozilla::safebrowsing::RawIndices& raw_indices() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::RawIndices* release_raw_indices();
+  ::mozilla::safebrowsing::RawIndices* mutable_raw_indices();
+  void set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices);
+  private:
+  const ::mozilla::safebrowsing::RawIndices& _internal_raw_indices() const;
+  ::mozilla::safebrowsing::RawIndices* _internal_mutable_raw_indices();
+  public:
+  void unsafe_arena_set_allocated_raw_indices(
+      ::mozilla::safebrowsing::RawIndices* raw_indices);
+  ::mozilla::safebrowsing::RawIndices* unsafe_arena_release_raw_indices();
+
+  // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+  bool has_rice_hashes() const;
+  private:
+  bool _internal_has_rice_hashes() const;
+  public:
+  void clear_rice_hashes();
+  const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_hashes() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_hashes();
+  ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_hashes();
+  void set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes);
+  private:
+  const ::mozilla::safebrowsing::RiceDeltaEncoding& _internal_rice_hashes() const;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* _internal_mutable_rice_hashes();
+  public:
+  void unsafe_arena_set_allocated_rice_hashes(
+      ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes);
+  ::mozilla::safebrowsing::RiceDeltaEncoding* unsafe_arena_release_rice_hashes();
+
+  // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+  bool has_rice_indices() const;
+  private:
+  bool _internal_has_rice_indices() const;
+  public:
+  void clear_rice_indices();
+  const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_indices() const;
+  PROTOBUF_NODISCARD ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_indices();
+  ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_indices();
+  void set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices);
+  private:
+  const ::mozilla::safebrowsing::RiceDeltaEncoding& _internal_rice_indices() const;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* _internal_mutable_rice_indices();
+  public:
+  void unsafe_arena_set_allocated_rice_indices(
+      ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices);
+  ::mozilla::safebrowsing::RiceDeltaEncoding* unsafe_arena_release_rice_indices();
+
+  // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+  bool has_compression_type() const;
+  private:
+  bool _internal_has_compression_type() const;
+  public:
+  void clear_compression_type();
+  ::mozilla::safebrowsing::CompressionType compression_type() const;
+  void set_compression_type(::mozilla::safebrowsing::CompressionType value);
+  private:
+  ::mozilla::safebrowsing::CompressionType _internal_compression_type() const;
+  void _internal_set_compression_type(::mozilla::safebrowsing::CompressionType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntrySet)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::mozilla::safebrowsing::RawHashes* raw_hashes_;
+    ::mozilla::safebrowsing::RawIndices* raw_indices_;
+    ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes_;
+    ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices_;
+    int compression_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RawIndices final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RawIndices) */ {
+ public:
+  inline RawIndices() : RawIndices(nullptr) {}
+  ~RawIndices() override;
+  explicit PROTOBUF_CONSTEXPR RawIndices(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RawIndices(const RawIndices& from);
+  RawIndices(RawIndices&& from) noexcept
+    : RawIndices() {
+    *this = ::std::move(from);
+  }
+
+  inline RawIndices& operator=(const RawIndices& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RawIndices& operator=(RawIndices&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const RawIndices& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RawIndices* internal_default_instance() {
+    return reinterpret_cast<const RawIndices*>(
+               &_RawIndices_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(RawIndices& a, RawIndices& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RawIndices* 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(RawIndices* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RawIndices* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RawIndices>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const RawIndices& from);
+  void MergeFrom(const RawIndices& 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(RawIndices* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.RawIndices";
+  }
+  protected:
+  explicit RawIndices(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIndicesFieldNumber = 1,
+  };
+  // repeated int32 indices = 1;
+  int indices_size() const;
+  private:
+  int _internal_indices_size() const;
+  public:
+  void clear_indices();
+  private:
+  int32_t _internal_indices(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_indices() const;
+  void _internal_add_indices(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_indices();
+  public:
+  int32_t indices(int index) const;
+  void set_indices(int index, int32_t value);
+  void add_indices(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      indices() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_indices();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawIndices)
+ 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< int32_t > indices_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RawHashes final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RawHashes) */ {
+ public:
+  inline RawHashes() : RawHashes(nullptr) {}
+  ~RawHashes() override;
+  explicit PROTOBUF_CONSTEXPR RawHashes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RawHashes(const RawHashes& from);
+  RawHashes(RawHashes&& from) noexcept
+    : RawHashes() {
+    *this = ::std::move(from);
+  }
+
+  inline RawHashes& operator=(const RawHashes& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RawHashes& operator=(RawHashes&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const RawHashes& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RawHashes* internal_default_instance() {
+    return reinterpret_cast<const RawHashes*>(
+               &_RawHashes_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(RawHashes& a, RawHashes& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RawHashes* 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(RawHashes* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RawHashes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RawHashes>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const RawHashes& from);
+  void MergeFrom(const RawHashes& 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(RawHashes* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.RawHashes";
+  }
+  protected:
+  explicit RawHashes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRawHashesFieldNumber = 2,
+    kPrefixSizeFieldNumber = 1,
+  };
+  // optional bytes raw_hashes = 2;
+  bool has_raw_hashes() const;
+  private:
+  bool _internal_has_raw_hashes() const;
+  public:
+  void clear_raw_hashes();
+  const std::string& raw_hashes() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_raw_hashes(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_raw_hashes();
+  PROTOBUF_NODISCARD std::string* release_raw_hashes();
+  void set_allocated_raw_hashes(std::string* raw_hashes);
+  private:
+  const std::string& _internal_raw_hashes() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_hashes(const std::string& value);
+  std::string* _internal_mutable_raw_hashes();
+  public:
+
+  // optional int32 prefix_size = 1;
+  bool has_prefix_size() const;
+  private:
+  bool _internal_has_prefix_size() const;
+  public:
+  void clear_prefix_size();
+  int32_t prefix_size() const;
+  void set_prefix_size(int32_t value);
+  private:
+  int32_t _internal_prefix_size() const;
+  void _internal_set_prefix_size(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawHashes)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_hashes_;
+    int32_t prefix_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RiceDeltaEncoding final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.RiceDeltaEncoding) */ {
+ public:
+  inline RiceDeltaEncoding() : RiceDeltaEncoding(nullptr) {}
+  ~RiceDeltaEncoding() override;
+  explicit PROTOBUF_CONSTEXPR RiceDeltaEncoding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RiceDeltaEncoding(const RiceDeltaEncoding& from);
+  RiceDeltaEncoding(RiceDeltaEncoding&& from) noexcept
+    : RiceDeltaEncoding() {
+    *this = ::std::move(from);
+  }
+
+  inline RiceDeltaEncoding& operator=(const RiceDeltaEncoding& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RiceDeltaEncoding& operator=(RiceDeltaEncoding&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const RiceDeltaEncoding& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RiceDeltaEncoding* internal_default_instance() {
+    return reinterpret_cast<const RiceDeltaEncoding*>(
+               &_RiceDeltaEncoding_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(RiceDeltaEncoding& a, RiceDeltaEncoding& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RiceDeltaEncoding* 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(RiceDeltaEncoding* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RiceDeltaEncoding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RiceDeltaEncoding>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const RiceDeltaEncoding& from);
+  void MergeFrom(const RiceDeltaEncoding& 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(RiceDeltaEncoding* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.RiceDeltaEncoding";
+  }
+  protected:
+  explicit RiceDeltaEncoding(::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,
+    kNumEntriesFieldNumber = 3,
+  };
+  // optional bytes encoded_data = 4;
+  bool has_encoded_data() const;
+  private:
+  bool _internal_has_encoded_data() const;
+  public:
+  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:
+
+  // optional int64 first_value = 1;
+  bool has_first_value() const;
+  private:
+  bool _internal_has_first_value() const;
+  public:
+  void clear_first_value();
+  int64_t first_value() const;
+  void set_first_value(int64_t value);
+  private:
+  int64_t _internal_first_value() const;
+  void _internal_set_first_value(int64_t value);
+  public:
+
+  // optional int32 rice_parameter = 2;
+  bool has_rice_parameter() const;
+  private:
+  bool _internal_has_rice_parameter() const;
+  public:
+  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:
+
+  // optional int32 num_entries = 3;
+  bool has_num_entries() const;
+  private:
+  bool _internal_has_num_entries() const;
+  public:
+  void clear_num_entries();
+  int32_t num_entries() const;
+  void set_num_entries(int32_t value);
+  private:
+  int32_t _internal_num_entries() const;
+  void _internal_set_num_entries(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RiceDeltaEncoding)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_data_;
+    int64_t first_value_;
+    int32_t rice_parameter_;
+    int32_t num_entries_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntryMetadata_MetadataEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry) */ {
+ public:
+  inline ThreatEntryMetadata_MetadataEntry() : ThreatEntryMetadata_MetadataEntry(nullptr) {}
+  ~ThreatEntryMetadata_MetadataEntry() override;
+  explicit PROTOBUF_CONSTEXPR ThreatEntryMetadata_MetadataEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from);
+  ThreatEntryMetadata_MetadataEntry(ThreatEntryMetadata_MetadataEntry&& from) noexcept
+    : ThreatEntryMetadata_MetadataEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatEntryMetadata_MetadataEntry& operator=(const ThreatEntryMetadata_MetadataEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatEntryMetadata_MetadataEntry& operator=(ThreatEntryMetadata_MetadataEntry&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatEntryMetadata_MetadataEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatEntryMetadata_MetadataEntry* internal_default_instance() {
+    return reinterpret_cast<const ThreatEntryMetadata_MetadataEntry*>(
+               &_ThreatEntryMetadata_MetadataEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(ThreatEntryMetadata_MetadataEntry& a, ThreatEntryMetadata_MetadataEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatEntryMetadata_MetadataEntry* 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(ThreatEntryMetadata_MetadataEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntryMetadata_MetadataEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatEntryMetadata_MetadataEntry>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatEntryMetadata_MetadataEntry& from);
+  void MergeFrom(const ThreatEntryMetadata_MetadataEntry& 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(ThreatEntryMetadata_MetadataEntry* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry";
+  }
+  protected:
+  explicit ThreatEntryMetadata_MetadataEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // optional bytes key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_NODISCARD std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional bytes value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntryMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatEntryMetadata) */ {
+ public:
+  inline ThreatEntryMetadata() : ThreatEntryMetadata(nullptr) {}
+  ~ThreatEntryMetadata() override;
+  explicit PROTOBUF_CONSTEXPR ThreatEntryMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatEntryMetadata(const ThreatEntryMetadata& from);
+  ThreatEntryMetadata(ThreatEntryMetadata&& from) noexcept
+    : ThreatEntryMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatEntryMetadata& operator=(const ThreatEntryMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatEntryMetadata& operator=(ThreatEntryMetadata&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatEntryMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatEntryMetadata* internal_default_instance() {
+    return reinterpret_cast<const ThreatEntryMetadata*>(
+               &_ThreatEntryMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(ThreatEntryMetadata& a, ThreatEntryMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatEntryMetadata* 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(ThreatEntryMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntryMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatEntryMetadata>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatEntryMetadata& from);
+  void MergeFrom(const ThreatEntryMetadata& 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(ThreatEntryMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatEntryMetadata";
+  }
+  protected:
+  explicit ThreatEntryMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ThreatEntryMetadata_MetadataEntry MetadataEntry;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntriesFieldNumber = 1,
+  };
+  // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+  int entries_size() const;
+  private:
+  int _internal_entries_size() const;
+  public:
+  void clear_entries();
+  ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* mutable_entries(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >*
+      mutable_entries();
+  private:
+  const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& _internal_entries(int index) const;
+  ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* _internal_add_entries();
+  public:
+  const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& entries(int index) const;
+  ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* add_entries();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >&
+      entries() const;
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata)
+ 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::ThreatEntryMetadata_MetadataEntry > entries_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreatListDescriptor final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ThreatListDescriptor) */ {
+ public:
+  inline ThreatListDescriptor() : ThreatListDescriptor(nullptr) {}
+  ~ThreatListDescriptor() override;
+  explicit PROTOBUF_CONSTEXPR ThreatListDescriptor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreatListDescriptor(const ThreatListDescriptor& from);
+  ThreatListDescriptor(ThreatListDescriptor&& from) noexcept
+    : ThreatListDescriptor() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreatListDescriptor& operator=(const ThreatListDescriptor& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreatListDescriptor& operator=(ThreatListDescriptor&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ThreatListDescriptor& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ThreatListDescriptor* internal_default_instance() {
+    return reinterpret_cast<const ThreatListDescriptor*>(
+               &_ThreatListDescriptor_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(ThreatListDescriptor& a, ThreatListDescriptor& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreatListDescriptor* 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(ThreatListDescriptor* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreatListDescriptor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreatListDescriptor>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ThreatListDescriptor& from);
+  void MergeFrom(const ThreatListDescriptor& 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(ThreatListDescriptor* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ThreatListDescriptor";
+  }
+  protected:
+  explicit ThreatListDescriptor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kThreatTypeFieldNumber = 1,
+    kPlatformTypeFieldNumber = 2,
+    kThreatEntryTypeFieldNumber = 3,
+  };
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  bool has_threat_type() const;
+  private:
+  bool _internal_has_threat_type() const;
+  public:
+  void clear_threat_type();
+  ::mozilla::safebrowsing::ThreatType threat_type() const;
+  void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  private:
+  ::mozilla::safebrowsing::ThreatType _internal_threat_type() const;
+  void _internal_set_threat_type(::mozilla::safebrowsing::ThreatType value);
+  public:
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  bool has_platform_type() const;
+  private:
+  bool _internal_has_platform_type() const;
+  public:
+  void clear_platform_type();
+  ::mozilla::safebrowsing::PlatformType platform_type() const;
+  void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  private:
+  ::mozilla::safebrowsing::PlatformType _internal_platform_type() const;
+  void _internal_set_platform_type(::mozilla::safebrowsing::PlatformType value);
+  public:
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+  bool has_threat_entry_type() const;
+  private:
+  bool _internal_has_threat_entry_type() const;
+  public:
+  void clear_threat_entry_type();
+  ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  private:
+  ::mozilla::safebrowsing::ThreatEntryType _internal_threat_entry_type() const;
+  void _internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatListDescriptor)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int threat_type_;
+    int platform_type_;
+    int threat_entry_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ListThreatListsResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.ListThreatListsResponse) */ {
+ public:
+  inline ListThreatListsResponse() : ListThreatListsResponse(nullptr) {}
+  ~ListThreatListsResponse() override;
+  explicit PROTOBUF_CONSTEXPR ListThreatListsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ListThreatListsResponse(const ListThreatListsResponse& from);
+  ListThreatListsResponse(ListThreatListsResponse&& from) noexcept
+    : ListThreatListsResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ListThreatListsResponse& operator=(const ListThreatListsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ListThreatListsResponse& operator=(ListThreatListsResponse&& 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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ListThreatListsResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ListThreatListsResponse* internal_default_instance() {
+    return reinterpret_cast<const ListThreatListsResponse*>(
+               &_ListThreatListsResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(ListThreatListsResponse& a, ListThreatListsResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ListThreatListsResponse* 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(ListThreatListsResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ListThreatListsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ListThreatListsResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ListThreatListsResponse& from);
+  void MergeFrom(const ListThreatListsResponse& 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(ListThreatListsResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "mozilla.safebrowsing.ListThreatListsResponse";
+  }
+  protected:
+  explicit ListThreatListsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kThreatListsFieldNumber = 1,
+  };
+  // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+  int threat_lists_size() const;
+  private:
+  int _internal_threat_lists_size() const;
+  public:
+  void clear_threat_lists();
+  ::mozilla::safebrowsing::ThreatListDescriptor* mutable_threat_lists(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >*
+      mutable_threat_lists();
+  private:
+  const ::mozilla::safebrowsing::ThreatListDescriptor& _internal_threat_lists(int index) const;
+  ::mozilla::safebrowsing::ThreatListDescriptor* _internal_add_threat_lists();
+  public:
+  const ::mozilla::safebrowsing::ThreatListDescriptor& threat_lists(int index) const;
+  ::mozilla::safebrowsing::ThreatListDescriptor* add_threat_lists();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >&
+      threat_lists() const;
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ListThreatListsResponse)
+ 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::ThreatListDescriptor > threat_lists_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Duration final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mozilla.safebrowsing.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;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  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 =
+    26;
+
+  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.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,
+  };
+  // optional int64 seconds = 1;
+  bool has_seconds() const;
+  private:
+  bool _internal_has_seconds() const;
+  public:
+  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:
+
+  // optional int32 nanos = 2;
+  bool has_nanos() const;
+  private:
+  bool _internal_has_nanos() const;
+  public:
+  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.Duration)
+ 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::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t seconds_;
+    int32_t nanos_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_safebrowsing_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ThreatInfo
+
+// repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+inline int ThreatInfo::_internal_threat_types_size() const {
+  return _impl_.threat_types_.size();
+}
+inline int ThreatInfo::threat_types_size() const {
+  return _internal_threat_types_size();
+}
+inline void ThreatInfo::clear_threat_types() {
+  _impl_.threat_types_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatInfo::_internal_threat_types(int index) const {
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_types_.Get(index));
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatInfo::threat_types(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_types)
+  return _internal_threat_types(index);
+}
+inline void ThreatInfo::set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_.threat_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_types)
+}
+inline void ThreatInfo::_internal_add_threat_types(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_.threat_types_.Add(value);
+}
+inline void ThreatInfo::add_threat_types(::mozilla::safebrowsing::ThreatType value) {
+  _internal_add_threat_types(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_types)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+ThreatInfo::threat_types() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_types)
+  return _impl_.threat_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ThreatInfo::_internal_mutable_threat_types() {
+  return &_impl_.threat_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ThreatInfo::mutable_threat_types() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_types)
+  return _internal_mutable_threat_types();
+}
+
+// repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+inline int ThreatInfo::_internal_platform_types_size() const {
+  return _impl_.platform_types_.size();
+}
+inline int ThreatInfo::platform_types_size() const {
+  return _internal_platform_types_size();
+}
+inline void ThreatInfo::clear_platform_types() {
+  _impl_.platform_types_.Clear();
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatInfo::_internal_platform_types(int index) const {
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_types_.Get(index));
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatInfo::platform_types(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.platform_types)
+  return _internal_platform_types(index);
+}
+inline void ThreatInfo::set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_.platform_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.platform_types)
+}
+inline void ThreatInfo::_internal_add_platform_types(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_.platform_types_.Add(value);
+}
+inline void ThreatInfo::add_platform_types(::mozilla::safebrowsing::PlatformType value) {
+  _internal_add_platform_types(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.platform_types)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+ThreatInfo::platform_types() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.platform_types)
+  return _impl_.platform_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ThreatInfo::_internal_mutable_platform_types() {
+  return &_impl_.platform_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ThreatInfo::mutable_platform_types() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.platform_types)
+  return _internal_mutable_platform_types();
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+inline int ThreatInfo::_internal_threat_entry_types_size() const {
+  return _impl_.threat_entry_types_.size();
+}
+inline int ThreatInfo::threat_entry_types_size() const {
+  return _internal_threat_entry_types_size();
+}
+inline void ThreatInfo::clear_threat_entry_types() {
+  _impl_.threat_entry_types_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::_internal_threat_entry_types(int index) const {
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_types_.Get(index));
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::threat_entry_types(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+  return _internal_threat_entry_types(index);
+}
+inline void ThreatInfo::set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  _impl_.threat_entry_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+}
+inline void ThreatInfo::_internal_add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  _impl_.threat_entry_types_.Add(value);
+}
+inline void ThreatInfo::add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) {
+  _internal_add_threat_entry_types(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+ThreatInfo::threat_entry_types() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+  return _impl_.threat_entry_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ThreatInfo::_internal_mutable_threat_entry_types() {
+  return &_impl_.threat_entry_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ThreatInfo::mutable_threat_entry_types() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+  return _internal_mutable_threat_entry_types();
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+inline int ThreatInfo::_internal_threat_entries_size() const {
+  return _impl_.threat_entries_.size();
+}
+inline int ThreatInfo::threat_entries_size() const {
+  return _internal_threat_entries_size();
+}
+inline void ThreatInfo::clear_threat_entries() {
+  _impl_.threat_entries_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::mutable_threat_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return _impl_.threat_entries_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >*
+ThreatInfo::mutable_threat_entries() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return &_impl_.threat_entries_;
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::_internal_threat_entries(int index) const {
+  return _impl_.threat_entries_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::threat_entries(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return _internal_threat_entries(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::_internal_add_threat_entries() {
+  return _impl_.threat_entries_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::add_threat_entries() {
+  ::mozilla::safebrowsing::ThreatEntry* _add = _internal_add_threat_entries();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >&
+ThreatInfo::threat_entries() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return _impl_.threat_entries_;
+}
+
+// -------------------------------------------------------------------
+
+// ThreatMatch
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool ThreatMatch::_internal_has_threat_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ThreatMatch::has_threat_type() const {
+  return _internal_has_threat_type();
+}
+inline void ThreatMatch::clear_threat_type() {
+  _impl_.threat_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatMatch::_internal_threat_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_);
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatMatch::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_type)
+  return _internal_threat_type();
+}
+inline void ThreatMatch::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.threat_type_ = value;
+}
+inline void ThreatMatch::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  _internal_set_threat_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool ThreatMatch::_internal_has_platform_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ThreatMatch::has_platform_type() const {
+  return _internal_has_platform_type();
+}
+inline void ThreatMatch::clear_platform_type() {
+  _impl_.platform_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatMatch::_internal_platform_type() const {
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_);
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatMatch::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.platform_type)
+  return _internal_platform_type();
+}
+inline void ThreatMatch::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.platform_type_ = value;
+}
+inline void ThreatMatch::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  _internal_set_platform_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+inline bool ThreatMatch::_internal_has_threat_entry_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ThreatMatch::has_threat_entry_type() const {
+  return _internal_has_threat_entry_type();
+}
+inline void ThreatMatch::clear_threat_entry_type() {
+  _impl_.threat_entry_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::_internal_threat_entry_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_);
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_type)
+  return _internal_threat_entry_type();
+}
+inline void ThreatMatch::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.threat_entry_type_ = value;
+}
+inline void ThreatMatch::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  _internal_set_threat_entry_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_entry_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+inline bool ThreatMatch::_internal_has_threat() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.threat_ != nullptr);
+  return value;
+}
+inline bool ThreatMatch::has_threat() const {
+  return _internal_has_threat();
+}
+inline void ThreatMatch::clear_threat() {
+  if (_impl_.threat_ != nullptr) _impl_.threat_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::_internal_threat() const {
+  const ::mozilla::safebrowsing::ThreatEntry* p = _impl_.threat_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntry&>(
+      ::mozilla::safebrowsing::_ThreatEntry_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::threat() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat)
+  return _internal_threat();
+}
+inline void ThreatMatch::unsafe_arena_set_allocated_threat(
+    ::mozilla::safebrowsing::ThreatEntry* threat) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_);
+  }
+  _impl_.threat_ = threat;
+  if (threat) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatMatch.threat)
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::release_threat() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.threat_;
+  _impl_.threat_ = 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::ThreatEntry* ThreatMatch::unsafe_arena_release_threat() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.threat)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.threat_;
+  _impl_.threat_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::_internal_mutable_threat() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.threat_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(GetArenaForAllocation());
+    _impl_.threat_ = p;
+  }
+  return _impl_.threat_;
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::mutable_threat() {
+  ::mozilla::safebrowsing::ThreatEntry* _msg = _internal_mutable_threat();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat)
+  return _msg;
+}
+inline void ThreatMatch::set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.threat_;
+  }
+  if (threat) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat);
+    if (message_arena != submessage_arena) {
+      threat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, threat, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.threat_ = threat;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+inline bool ThreatMatch::_internal_has_threat_entry_metadata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.threat_entry_metadata_ != nullptr);
+  return value;
+}
+inline bool ThreatMatch::has_threat_entry_metadata() const {
+  return _internal_has_threat_entry_metadata();
+}
+inline void ThreatMatch::clear_threat_entry_metadata() {
+  if (_impl_.threat_entry_metadata_ != nullptr) _impl_.threat_entry_metadata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::_internal_threat_entry_metadata() const {
+  const ::mozilla::safebrowsing::ThreatEntryMetadata* p = _impl_.threat_entry_metadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntryMetadata&>(
+      ::mozilla::safebrowsing::_ThreatEntryMetadata_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::threat_entry_metadata() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+  return _internal_threat_entry_metadata();
+}
+inline void ThreatMatch::unsafe_arena_set_allocated_threat_entry_metadata(
+    ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_entry_metadata_);
+  }
+  _impl_.threat_entry_metadata_ = threat_entry_metadata;
+  if (threat_entry_metadata) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::release_threat_entry_metadata() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ThreatEntryMetadata* temp = _impl_.threat_entry_metadata_;
+  _impl_.threat_entry_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::ThreatEntryMetadata* ThreatMatch::unsafe_arena_release_threat_entry_metadata() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ThreatEntryMetadata* temp = _impl_.threat_entry_metadata_;
+  _impl_.threat_entry_metadata_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::_internal_mutable_threat_entry_metadata() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.threat_entry_metadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntryMetadata>(GetArenaForAllocation());
+    _impl_.threat_entry_metadata_ = p;
+  }
+  return _impl_.threat_entry_metadata_;
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::mutable_threat_entry_metadata() {
+  ::mozilla::safebrowsing::ThreatEntryMetadata* _msg = _internal_mutable_threat_entry_metadata();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+  return _msg;
+}
+inline void ThreatMatch::set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.threat_entry_metadata_;
+  }
+  if (threat_entry_metadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat_entry_metadata);
+    if (message_arena != submessage_arena) {
+      threat_entry_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, threat_entry_metadata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.threat_entry_metadata_ = threat_entry_metadata;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+}
+
+// optional .mozilla.safebrowsing.Duration cache_duration = 5;
+inline bool ThreatMatch::_internal_has_cache_duration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.cache_duration_ != nullptr);
+  return value;
+}
+inline bool ThreatMatch::has_cache_duration() const {
+  return _internal_has_cache_duration();
+}
+inline void ThreatMatch::clear_cache_duration() {
+  if (_impl_.cache_duration_ != nullptr) _impl_.cache_duration_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::mozilla::safebrowsing::Duration& ThreatMatch::_internal_cache_duration() const {
+  const ::mozilla::safebrowsing::Duration* p = _impl_.cache_duration_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>(
+      ::mozilla::safebrowsing::_Duration_default_instance_);
+}
+inline const ::mozilla::safebrowsing::Duration& ThreatMatch::cache_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.cache_duration)
+  return _internal_cache_duration();
+}
+inline void ThreatMatch::unsafe_arena_set_allocated_cache_duration(
+    ::mozilla::safebrowsing::Duration* cache_duration) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cache_duration_);
+  }
+  _impl_.cache_duration_ = cache_duration;
+  if (cache_duration) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration)
+}
+inline ::mozilla::safebrowsing::Duration* ThreatMatch::release_cache_duration() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::mozilla::safebrowsing::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::Duration* ThreatMatch::unsafe_arena_release_cache_duration() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatMatch.cache_duration)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::mozilla::safebrowsing::Duration* temp = _impl_.cache_duration_;
+  _impl_.cache_duration_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::Duration* ThreatMatch::_internal_mutable_cache_duration() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.cache_duration_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation());
+    _impl_.cache_duration_ = p;
+  }
+  return _impl_.cache_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* ThreatMatch::mutable_cache_duration() {
+  ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_cache_duration();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.cache_duration)
+  return _msg;
+}
+inline void ThreatMatch::set_allocated_cache_duration(::mozilla::safebrowsing::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);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.cache_duration_ = cache_duration;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration)
+}
+
+// -------------------------------------------------------------------
+
+// FindThreatMatchesRequest
+
+// optional .mozilla.safebrowsing.ClientInfo client = 1;
+inline bool FindThreatMatchesRequest::_internal_has_client() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.client_ != nullptr);
+  return value;
+}
+inline bool FindThreatMatchesRequest::has_client() const {
+  return _internal_has_client();
+}
+inline void FindThreatMatchesRequest::clear_client() {
+  if (_impl_.client_ != nullptr) _impl_.client_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::_internal_client() const {
+  const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>(
+      ::mozilla::safebrowsing::_ClientInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::client() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+  return _internal_client();
+}
+inline void FindThreatMatchesRequest::unsafe_arena_set_allocated_client(
+    ::mozilla::safebrowsing::ClientInfo* client) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_);
+  }
+  _impl_.client_ = client;
+  if (client) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::release_client() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_;
+  _impl_.client_ = 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::ClientInfo* FindThreatMatchesRequest::unsafe_arena_release_client() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_;
+  _impl_.client_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::_internal_mutable_client() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.client_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation());
+    _impl_.client_ = p;
+  }
+  return _impl_.client_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::mutable_client() {
+  ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+  return _msg;
+}
+inline void FindThreatMatchesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.client_;
+  }
+  if (client) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client);
+    if (message_arena != submessage_arena) {
+      client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.client_ = client;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+}
+
+// optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+inline bool FindThreatMatchesRequest::_internal_has_threat_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.threat_info_ != nullptr);
+  return value;
+}
+inline bool FindThreatMatchesRequest::has_threat_info() const {
+  return _internal_has_threat_info();
+}
+inline void FindThreatMatchesRequest::clear_threat_info() {
+  if (_impl_.threat_info_ != nullptr) _impl_.threat_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::_internal_threat_info() const {
+  const ::mozilla::safebrowsing::ThreatInfo* p = _impl_.threat_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatInfo&>(
+      ::mozilla::safebrowsing::_ThreatInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::threat_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+  return _internal_threat_info();
+}
+inline void FindThreatMatchesRequest::unsafe_arena_set_allocated_threat_info(
+    ::mozilla::safebrowsing::ThreatInfo* threat_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_info_);
+  }
+  _impl_.threat_info_ = threat_info;
+  if (threat_info) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::release_threat_info() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_;
+  _impl_.threat_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::unsafe_arena_release_threat_info() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_;
+  _impl_.threat_info_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::_internal_mutable_threat_info() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.threat_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(GetArenaForAllocation());
+    _impl_.threat_info_ = p;
+  }
+  return _impl_.threat_info_;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::mutable_threat_info() {
+  ::mozilla::safebrowsing::ThreatInfo* _msg = _internal_mutable_threat_info();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+  return _msg;
+}
+inline void FindThreatMatchesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.threat_info_;
+  }
+  if (threat_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat_info);
+    if (message_arena != submessage_arena) {
+      threat_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, threat_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.threat_info_ = threat_info;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+}
+
+// -------------------------------------------------------------------
+
+// FindThreatMatchesResponse
+
+// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+inline int FindThreatMatchesResponse::_internal_matches_size() const {
+  return _impl_.matches_.size();
+}
+inline int FindThreatMatchesResponse::matches_size() const {
+  return _internal_matches_size();
+}
+inline void FindThreatMatchesResponse::clear_matches() {
+  _impl_.matches_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::mutable_matches(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return _impl_.matches_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+FindThreatMatchesResponse::mutable_matches() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return &_impl_.matches_;
+}
+inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::_internal_matches(int index) const {
+  return _impl_.matches_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::matches(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return _internal_matches(index);
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::_internal_add_matches() {
+  return _impl_.matches_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::add_matches() {
+  ::mozilla::safebrowsing::ThreatMatch* _add = _internal_add_matches();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+FindThreatMatchesResponse::matches() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return _impl_.matches_;
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints
+
+// optional int32 max_update_entries = 1;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_max_update_entries() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_update_entries() const {
+  return _internal_has_max_update_entries();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_update_entries() {
+  _impl_.max_update_entries_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_max_update_entries() const {
+  return _impl_.max_update_entries_;
+}
+inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_update_entries() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries)
+  return _internal_max_update_entries();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_max_update_entries(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.max_update_entries_ = value;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_update_entries(int32_t value) {
+  _internal_set_max_update_entries(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries)
+}
+
+// optional int32 max_database_entries = 2;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_max_database_entries() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_database_entries() const {
+  return _internal_has_max_database_entries();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_database_entries() {
+  _impl_.max_database_entries_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_max_database_entries() const {
+  return _impl_.max_database_entries_;
+}
+inline int32_t FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_database_entries() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries)
+  return _internal_max_database_entries();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_max_database_entries(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.max_database_entries_ = value;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_database_entries(int32_t value) {
+  _internal_set_max_database_entries(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries)
+}
+
+// optional string region = 3;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_has_region() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_region() const {
+  return _internal_has_region();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_region() {
+  _impl_.region_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::region() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+  return _internal_region();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.region_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+}
+inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_region() {
+  std::string* _s = _internal_mutable_region();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+  return _s;
+}
+inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_region() const {
+  return _impl_.region_.Get();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_set_region(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.region_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_mutable_region() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.region_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::release_region() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+  if (!_internal_has_region()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.region_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.region_.IsDefault()) {
+    _impl_.region_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_allocated_region(std::string* region) {
+  if (region != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.region_.SetAllocated(region, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.region_.IsDefault()) {
+    _impl_.region_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+}
+
+// repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_supported_compressions_size() const {
+  return _impl_.supported_compressions_.size();
+}
+inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions_size() const {
+  return _internal_supported_compressions_size();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_supported_compressions() {
+  _impl_.supported_compressions_.Clear();
+}
+inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_supported_compressions(int index) const {
+  return static_cast< ::mozilla::safebrowsing::CompressionType >(_impl_.supported_compressions_.Get(index));
+}
+inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+  return _internal_supported_compressions(index);
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value) {
+  assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
+  _impl_.supported_compressions_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_add_supported_compressions(::mozilla::safebrowsing::CompressionType value) {
+  assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
+  _impl_.supported_compressions_.Add(value);
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::add_supported_compressions(::mozilla::safebrowsing::CompressionType value) {
+  _internal_add_supported_compressions(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+  return _impl_.supported_compressions_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::_internal_mutable_supported_compressions() {
+  return &_impl_.supported_compressions_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_supported_compressions() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+  return _internal_mutable_supported_compressions();
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesRequest_ListUpdateRequest
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_threat_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_type() const {
+  return _internal_has_threat_type();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_type() {
+  _impl_.threat_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_threat_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_);
+}
+inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type)
+  return _internal_threat_type();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.threat_type_ = value;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  _internal_set_threat_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_platform_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_platform_type() const {
+  return _internal_has_platform_type();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_platform_type() {
+  _impl_.platform_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_platform_type() const {
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_);
+}
+inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type)
+  return _internal_platform_type();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.platform_type_ = value;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  _internal_set_platform_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_threat_entry_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_entry_type() const {
+  return _internal_has_threat_entry_type();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_entry_type() {
+  _impl_.threat_entry_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_threat_entry_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_);
+}
+inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type)
+  return _internal_threat_entry_type();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.threat_entry_type_ = value;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  _internal_set_threat_entry_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type)
+}
+
+// optional bytes state = 3;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_state() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_state() const {
+  return _internal_has_state();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_state() {
+  _impl_.state_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::state() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+  return _internal_state();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.state_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+}
+inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_state() {
+  std::string* _s = _internal_mutable_state();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+  return _s;
+}
+inline const std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_state() const {
+  return _impl_.state_.Get();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_set_state(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.state_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_mutable_state() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.state_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::release_state() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+  if (!_internal_has_state()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.state_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.state_.IsDefault()) {
+    _impl_.state_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_state(std::string* state) {
+  if (state != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.state_.SetAllocated(state, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.state_.IsDefault()) {
+    _impl_.state_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+}
+
+// optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_has_constraints() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.constraints_ != nullptr);
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_constraints() const {
+  return _internal_has_constraints();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_constraints() {
+  if (_impl_.constraints_ != nullptr) _impl_.constraints_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_constraints() const {
+  const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* p = _impl_.constraints_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints&>(
+      ::mozilla::safebrowsing::_FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints_default_instance_);
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::constraints() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+  return _internal_constraints();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::unsafe_arena_set_allocated_constraints(
+    ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.constraints_);
+  }
+  _impl_.constraints_ = constraints;
+  if (constraints) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::release_constraints() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = _impl_.constraints_;
+  _impl_.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::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::unsafe_arena_release_constraints() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = _impl_.constraints_;
+  _impl_.constraints_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::_internal_mutable_constraints() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.constraints_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints>(GetArenaForAllocation());
+    _impl_.constraints_ = p;
+  }
+  return _impl_.constraints_;
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_constraints() {
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* _msg = _internal_mutable_constraints();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+  return _msg;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.constraints_;
+  }
+  if (constraints) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(constraints);
+    if (message_arena != submessage_arena) {
+      constraints = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, constraints, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.constraints_ = constraints;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesRequest
+
+// optional .mozilla.safebrowsing.ClientInfo client = 1;
+inline bool FetchThreatListUpdatesRequest::_internal_has_client() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.client_ != nullptr);
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest::has_client() const {
+  return _internal_has_client();
+}
+inline void FetchThreatListUpdatesRequest::clear_client() {
+  if (_impl_.client_ != nullptr) _impl_.client_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::_internal_client() const {
+  const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>(
+      ::mozilla::safebrowsing::_ClientInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::client() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+  return _internal_client();
+}
+inline void FetchThreatListUpdatesRequest::unsafe_arena_set_allocated_client(
+    ::mozilla::safebrowsing::ClientInfo* client) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_);
+  }
+  _impl_.client_ = client;
+  if (client) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+}
+inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::release_client() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_;
+  _impl_.client_ = 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::ClientInfo* FetchThreatListUpdatesRequest::unsafe_arena_release_client() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_;
+  _impl_.client_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::_internal_mutable_client() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.client_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation());
+    _impl_.client_ = p;
+  }
+  return _impl_.client_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::mutable_client() {
+  ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+  return _msg;
+}
+inline void FetchThreatListUpdatesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.client_;
+  }
+  if (client) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client);
+    if (message_arena != submessage_arena) {
+      client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.client_ = client;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+}
+
+// repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+inline int FetchThreatListUpdatesRequest::_internal_list_update_requests_size() const {
+  return _impl_.list_update_requests_.size();
+}
+inline int FetchThreatListUpdatesRequest::list_update_requests_size() const {
+  return _internal_list_update_requests_size();
+}
+inline void FetchThreatListUpdatesRequest::clear_list_update_requests() {
+  _impl_.list_update_requests_.Clear();
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::mutable_list_update_requests(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return _impl_.list_update_requests_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >*
+FetchThreatListUpdatesRequest::mutable_list_update_requests() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return &_impl_.list_update_requests_;
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::_internal_list_update_requests(int index) const {
+  return _impl_.list_update_requests_.Get(index);
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::list_update_requests(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return _internal_list_update_requests(index);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::_internal_add_list_update_requests() {
+  return _impl_.list_update_requests_.Add();
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::add_list_update_requests() {
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* _add = _internal_add_list_update_requests();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >&
+FetchThreatListUpdatesRequest::list_update_requests() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return _impl_.list_update_requests_;
+}
+
+// optional .mozilla.safebrowsing.ChromeClientInfo chrome_client_info = 4;
+inline bool FetchThreatListUpdatesRequest::_internal_has_chrome_client_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.chrome_client_info_ != nullptr);
+  return value;
+}
+inline bool FetchThreatListUpdatesRequest::has_chrome_client_info() const {
+  return _internal_has_chrome_client_info();
+}
+inline void FetchThreatListUpdatesRequest::clear_chrome_client_info() {
+  if (_impl_.chrome_client_info_ != nullptr) _impl_.chrome_client_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::ChromeClientInfo& FetchThreatListUpdatesRequest::_internal_chrome_client_info() const {
+  const ::mozilla::safebrowsing::ChromeClientInfo* p = _impl_.chrome_client_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ChromeClientInfo&>(
+      ::mozilla::safebrowsing::_ChromeClientInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ChromeClientInfo& FetchThreatListUpdatesRequest::chrome_client_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
+  return _internal_chrome_client_info();
+}
+inline void FetchThreatListUpdatesRequest::unsafe_arena_set_allocated_chrome_client_info(
+    ::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chrome_client_info_);
+  }
+  _impl_.chrome_client_info_ = chrome_client_info;
+  if (chrome_client_info) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
+}
+inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::release_chrome_client_info() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ChromeClientInfo* temp = _impl_.chrome_client_info_;
+  _impl_.chrome_client_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::unsafe_arena_release_chrome_client_info() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ChromeClientInfo* temp = _impl_.chrome_client_info_;
+  _impl_.chrome_client_info_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::_internal_mutable_chrome_client_info() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.chrome_client_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ChromeClientInfo>(GetArenaForAllocation());
+    _impl_.chrome_client_info_ = p;
+  }
+  return _impl_.chrome_client_info_;
+}
+inline ::mozilla::safebrowsing::ChromeClientInfo* FetchThreatListUpdatesRequest::mutable_chrome_client_info() {
+  ::mozilla::safebrowsing::ChromeClientInfo* _msg = _internal_mutable_chrome_client_info();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
+  return _msg;
+}
+inline void FetchThreatListUpdatesRequest::set_allocated_chrome_client_info(::mozilla::safebrowsing::ChromeClientInfo* chrome_client_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.chrome_client_info_;
+  }
+  if (chrome_client_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chrome_client_info);
+    if (message_arena != submessage_arena) {
+      chrome_client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, chrome_client_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.chrome_client_info_ = chrome_client_info;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.chrome_client_info)
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesResponse_ListUpdateResponse
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_threat_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_type() const {
+  return _internal_has_threat_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_type() {
+  _impl_.threat_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_threat_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_);
+}
+inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type)
+  return _internal_threat_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.threat_type_ = value;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  _internal_set_threat_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_threat_entry_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_entry_type() const {
+  return _internal_has_threat_entry_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_entry_type() {
+  _impl_.threat_entry_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_threat_entry_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_);
+}
+inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type)
+  return _internal_threat_entry_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.threat_entry_type_ = value;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  _internal_set_threat_entry_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_platform_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_platform_type() const {
+  return _internal_has_platform_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_platform_type() {
+  _impl_.platform_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_platform_type() const {
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_);
+}
+inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type)
+  return _internal_platform_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.platform_type_ = value;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  _internal_set_platform_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type)
+}
+
+// optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_response_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_response_type() const {
+  return _internal_has_response_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_response_type() {
+  _impl_.response_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_response_type() const {
+  return static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(_impl_.response_type_);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::response_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type)
+  return _internal_response_type();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) {
+  assert(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.response_type_ = value;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) {
+  _internal_set_response_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type)
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+inline int FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_additions_size() const {
+  return _impl_.additions_.size();
+}
+inline int FetchThreatListUpdatesResponse_ListUpdateResponse::additions_size() const {
+  return _internal_additions_size();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_additions() {
+  _impl_.additions_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return _impl_.additions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return &_impl_.additions_;
+}
+inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_additions(int index) const {
+  return _impl_.additions_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::additions(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return _internal_additions(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_add_additions() {
+  return _impl_.additions_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_additions() {
+  ::mozilla::safebrowsing::ThreatEntrySet* _add = _internal_add_additions();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+FetchThreatListUpdatesResponse_ListUpdateResponse::additions() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return _impl_.additions_;
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+inline int FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_removals_size() const {
+  return _impl_.removals_.size();
+}
+inline int FetchThreatListUpdatesResponse_ListUpdateResponse::removals_size() const {
+  return _internal_removals_size();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_removals() {
+  _impl_.removals_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return _impl_.removals_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return &_impl_.removals_;
+}
+inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_removals(int index) const {
+  return _impl_.removals_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::removals(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return _internal_removals(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_add_removals() {
+  return _impl_.removals_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_removals() {
+  ::mozilla::safebrowsing::ThreatEntrySet* _add = _internal_add_removals();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+FetchThreatListUpdatesResponse_ListUpdateResponse::removals() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return _impl_.removals_;
+}
+
+// optional bytes new_client_state = 7;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_new_client_state() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_new_client_state() const {
+  return _internal_has_new_client_state();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_new_client_state() {
+  _impl_.new_client_state_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::new_client_state() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+  return _internal_new_client_state();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.new_client_state_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+}
+inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_new_client_state() {
+  std::string* _s = _internal_mutable_new_client_state();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+  return _s;
+}
+inline const std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_new_client_state() const {
+  return _impl_.new_client_state_.Get();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_set_new_client_state(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.new_client_state_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_mutable_new_client_state() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.new_client_state_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::release_new_client_state() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+  if (!_internal_has_new_client_state()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.new_client_state_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.new_client_state_.IsDefault()) {
+    _impl_.new_client_state_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_new_client_state(std::string* new_client_state) {
+  if (new_client_state != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.new_client_state_.SetAllocated(new_client_state, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.new_client_state_.IsDefault()) {
+    _impl_.new_client_state_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+}
+
+// optional .mozilla.safebrowsing.Checksum checksum = 8;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_has_checksum() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.checksum_ != nullptr);
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_checksum() const {
+  return _internal_has_checksum();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_checksum() {
+  if (_impl_.checksum_ != nullptr) _impl_.checksum_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_checksum() const {
+  const ::mozilla::safebrowsing::Checksum* p = _impl_.checksum_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Checksum&>(
+      ::mozilla::safebrowsing::_Checksum_default_instance_);
+}
+inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::checksum() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+  return _internal_checksum();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::unsafe_arena_set_allocated_checksum(
+    ::mozilla::safebrowsing::Checksum* checksum) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.checksum_);
+  }
+  _impl_.checksum_ = checksum;
+  if (checksum) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+}
+inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::release_checksum() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::Checksum* temp = _impl_.checksum_;
+  _impl_.checksum_ = 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::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::unsafe_arena_release_checksum() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::Checksum* temp = _impl_.checksum_;
+  _impl_.checksum_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::_internal_mutable_checksum() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.checksum_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Checksum>(GetArenaForAllocation());
+    _impl_.checksum_ = p;
+  }
+  return _impl_.checksum_;
+}
+inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_checksum() {
+  ::mozilla::safebrowsing::Checksum* _msg = _internal_mutable_checksum();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+  return _msg;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.checksum_;
+  }
+  if (checksum) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(checksum);
+    if (message_arena != submessage_arena) {
+      checksum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, checksum, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.checksum_ = checksum;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesResponse
+
+// repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+inline int FetchThreatListUpdatesResponse::_internal_list_update_responses_size() const {
+  return _impl_.list_update_responses_.size();
+}
+inline int FetchThreatListUpdatesResponse::list_update_responses_size() const {
+  return _internal_list_update_responses_size();
+}
+inline void FetchThreatListUpdatesResponse::clear_list_update_responses() {
+  _impl_.list_update_responses_.Clear();
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::mutable_list_update_responses(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return _impl_.list_update_responses_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >*
+FetchThreatListUpdatesResponse::mutable_list_update_responses() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return &_impl_.list_update_responses_;
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::_internal_list_update_responses(int index) const {
+  return _impl_.list_update_responses_.Get(index);
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::list_update_responses(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return _internal_list_update_responses(index);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::_internal_add_list_update_responses() {
+  return _impl_.list_update_responses_.Add();
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::add_list_update_responses() {
+  ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* _add = _internal_add_list_update_responses();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >&
+FetchThreatListUpdatesResponse::list_update_responses() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return _impl_.list_update_responses_;
+}
+
+// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+inline bool FetchThreatListUpdatesResponse::_internal_has_minimum_wait_duration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.minimum_wait_duration_ != nullptr);
+  return value;
+}
+inline bool FetchThreatListUpdatesResponse::has_minimum_wait_duration() const {
+  return _internal_has_minimum_wait_duration();
+}
+inline void FetchThreatListUpdatesResponse::clear_minimum_wait_duration() {
+  if (_impl_.minimum_wait_duration_ != nullptr) _impl_.minimum_wait_duration_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::_internal_minimum_wait_duration() const {
+  const ::mozilla::safebrowsing::Duration* p = _impl_.minimum_wait_duration_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>(
+      ::mozilla::safebrowsing::_Duration_default_instance_);
+}
+inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::minimum_wait_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+  return _internal_minimum_wait_duration();
+}
+inline void FetchThreatListUpdatesResponse::unsafe_arena_set_allocated_minimum_wait_duration(
+    ::mozilla::safebrowsing::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) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+}
+inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::release_minimum_wait_duration() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::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::Duration* FetchThreatListUpdatesResponse::unsafe_arena_release_minimum_wait_duration() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::Duration* temp = _impl_.minimum_wait_duration_;
+  _impl_.minimum_wait_duration_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::_internal_mutable_minimum_wait_duration() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.minimum_wait_duration_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation());
+    _impl_.minimum_wait_duration_ = p;
+  }
+  return _impl_.minimum_wait_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::mutable_minimum_wait_duration() {
+  ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_minimum_wait_duration();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+  return _msg;
+}
+inline void FetchThreatListUpdatesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::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);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.minimum_wait_duration_ = minimum_wait_duration;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+}
+
+// -------------------------------------------------------------------
+
+// FindFullHashesRequest
+
+// optional .mozilla.safebrowsing.ClientInfo client = 1;
+inline bool FindFullHashesRequest::_internal_has_client() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.client_ != nullptr);
+  return value;
+}
+inline bool FindFullHashesRequest::has_client() const {
+  return _internal_has_client();
+}
+inline void FindFullHashesRequest::clear_client() {
+  if (_impl_.client_ != nullptr) _impl_.client_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::_internal_client() const {
+  const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>(
+      ::mozilla::safebrowsing::_ClientInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::client() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client)
+  return _internal_client();
+}
+inline void FindFullHashesRequest::unsafe_arena_set_allocated_client(
+    ::mozilla::safebrowsing::ClientInfo* client) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_);
+  }
+  _impl_.client_ = client;
+  if (client) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client)
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::release_client() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_;
+  _impl_.client_ = 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::ClientInfo* FindFullHashesRequest::unsafe_arena_release_client() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesRequest.client)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_;
+  _impl_.client_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::_internal_mutable_client() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.client_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation());
+    _impl_.client_ = p;
+  }
+  return _impl_.client_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::mutable_client() {
+  ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client)
+  return _msg;
+}
+inline void FindFullHashesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.client_;
+  }
+  if (client) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client);
+    if (message_arena != submessage_arena) {
+      client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.client_ = client;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client)
+}
+
+// repeated bytes client_states = 2;
+inline int FindFullHashesRequest::_internal_client_states_size() const {
+  return _impl_.client_states_.size();
+}
+inline int FindFullHashesRequest::client_states_size() const {
+  return _internal_client_states_size();
+}
+inline void FindFullHashesRequest::clear_client_states() {
+  _impl_.client_states_.Clear();
+}
+inline std::string* FindFullHashesRequest::add_client_states() {
+  std::string* _s = _internal_add_client_states();
+  // @@protoc_insertion_point(field_add_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return _s;
+}
+inline const std::string& FindFullHashesRequest::_internal_client_states(int index) const {
+  return _impl_.client_states_.Get(index);
+}
+inline const std::string& FindFullHashesRequest::client_states(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return _internal_client_states(index);
+}
+inline std::string* FindFullHashesRequest::mutable_client_states(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return _impl_.client_states_.Mutable(index);
+}
+inline void FindFullHashesRequest::set_client_states(int index, const std::string& value) {
+  _impl_.client_states_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::set_client_states(int index, std::string&& value) {
+  _impl_.client_states_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::set_client_states(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.client_states_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::set_client_states(int index, const void* value, size_t size) {
+  _impl_.client_states_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline std::string* FindFullHashesRequest::_internal_add_client_states() {
+  return _impl_.client_states_.Add();
+}
+inline void FindFullHashesRequest::add_client_states(const std::string& value) {
+  _impl_.client_states_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::add_client_states(std::string&& value) {
+  _impl_.client_states_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::add_client_states(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.client_states_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::add_client_states(const void* value, size_t size) {
+  _impl_.client_states_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FindFullHashesRequest::client_states() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return _impl_.client_states_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FindFullHashesRequest::mutable_client_states() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return &_impl_.client_states_;
+}
+
+// optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+inline bool FindFullHashesRequest::_internal_has_threat_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.threat_info_ != nullptr);
+  return value;
+}
+inline bool FindFullHashesRequest::has_threat_info() const {
+  return _internal_has_threat_info();
+}
+inline void FindFullHashesRequest::clear_threat_info() {
+  if (_impl_.threat_info_ != nullptr) _impl_.threat_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::_internal_threat_info() const {
+  const ::mozilla::safebrowsing::ThreatInfo* p = _impl_.threat_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatInfo&>(
+      ::mozilla::safebrowsing::_ThreatInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::threat_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+  return _internal_threat_info();
+}
+inline void FindFullHashesRequest::unsafe_arena_set_allocated_threat_info(
+    ::mozilla::safebrowsing::ThreatInfo* threat_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threat_info_);
+  }
+  _impl_.threat_info_ = threat_info;
+  if (threat_info) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::release_threat_info() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_;
+  _impl_.threat_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::unsafe_arena_release_threat_info() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ThreatInfo* temp = _impl_.threat_info_;
+  _impl_.threat_info_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::_internal_mutable_threat_info() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.threat_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatInfo>(GetArenaForAllocation());
+    _impl_.threat_info_ = p;
+  }
+  return _impl_.threat_info_;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::mutable_threat_info() {
+  ::mozilla::safebrowsing::ThreatInfo* _msg = _internal_mutable_threat_info();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+  return _msg;
+}
+inline void FindFullHashesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.threat_info_;
+  }
+  if (threat_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threat_info);
+    if (message_arena != submessage_arena) {
+      threat_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, threat_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.threat_info_ = threat_info;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+}
+
+// -------------------------------------------------------------------
+
+// FindFullHashesResponse
+
+// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+inline int FindFullHashesResponse::_internal_matches_size() const {
+  return _impl_.matches_.size();
+}
+inline int FindFullHashesResponse::matches_size() const {
+  return _internal_matches_size();
+}
+inline void FindFullHashesResponse::clear_matches() {
+  _impl_.matches_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::mutable_matches(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return _impl_.matches_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+FindFullHashesResponse::mutable_matches() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return &_impl_.matches_;
+}
+inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::_internal_matches(int index) const {
+  return _impl_.matches_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::matches(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return _internal_matches(index);
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::_internal_add_matches() {
+  return _impl_.matches_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::add_matches() {
+  ::mozilla::safebrowsing::ThreatMatch* _add = _internal_add_matches();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+FindFullHashesResponse::matches() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return _impl_.matches_;
+}
+
+// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+inline bool FindFullHashesResponse::_internal_has_minimum_wait_duration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.minimum_wait_duration_ != nullptr);
+  return value;
+}
+inline bool FindFullHashesResponse::has_minimum_wait_duration() const {
+  return _internal_has_minimum_wait_duration();
+}
+inline void FindFullHashesResponse::clear_minimum_wait_duration() {
+  if (_impl_.minimum_wait_duration_ != nullptr) _impl_.minimum_wait_duration_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::_internal_minimum_wait_duration() const {
+  const ::mozilla::safebrowsing::Duration* p = _impl_.minimum_wait_duration_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>(
+      ::mozilla::safebrowsing::_Duration_default_instance_);
+}
+inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::minimum_wait_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+  return _internal_minimum_wait_duration();
+}
+inline void FindFullHashesResponse::unsafe_arena_set_allocated_minimum_wait_duration(
+    ::mozilla::safebrowsing::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) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_minimum_wait_duration() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::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::Duration* FindFullHashesResponse::unsafe_arena_release_minimum_wait_duration() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::Duration* temp = _impl_.minimum_wait_duration_;
+  _impl_.minimum_wait_duration_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::_internal_mutable_minimum_wait_duration() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.minimum_wait_duration_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation());
+    _impl_.minimum_wait_duration_ = p;
+  }
+  return _impl_.minimum_wait_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_minimum_wait_duration() {
+  ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_minimum_wait_duration();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+  return _msg;
+}
+inline void FindFullHashesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::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);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.minimum_wait_duration_ = minimum_wait_duration;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+}
+
+// optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+inline bool FindFullHashesResponse::_internal_has_negative_cache_duration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.negative_cache_duration_ != nullptr);
+  return value;
+}
+inline bool FindFullHashesResponse::has_negative_cache_duration() const {
+  return _internal_has_negative_cache_duration();
+}
+inline void FindFullHashesResponse::clear_negative_cache_duration() {
+  if (_impl_.negative_cache_duration_ != nullptr) _impl_.negative_cache_duration_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::_internal_negative_cache_duration() const {
+  const ::mozilla::safebrowsing::Duration* p = _impl_.negative_cache_duration_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::Duration&>(
+      ::mozilla::safebrowsing::_Duration_default_instance_);
+}
+inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::negative_cache_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+  return _internal_negative_cache_duration();
+}
+inline void FindFullHashesResponse::unsafe_arena_set_allocated_negative_cache_duration(
+    ::mozilla::safebrowsing::Duration* negative_cache_duration) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.negative_cache_duration_);
+  }
+  _impl_.negative_cache_duration_ = negative_cache_duration;
+  if (negative_cache_duration) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_negative_cache_duration() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::Duration* temp = _impl_.negative_cache_duration_;
+  _impl_.negative_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::Duration* FindFullHashesResponse::unsafe_arena_release_negative_cache_duration() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::Duration* temp = _impl_.negative_cache_duration_;
+  _impl_.negative_cache_duration_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::_internal_mutable_negative_cache_duration() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.negative_cache_duration_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::Duration>(GetArenaForAllocation());
+    _impl_.negative_cache_duration_ = p;
+  }
+  return _impl_.negative_cache_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_negative_cache_duration() {
+  ::mozilla::safebrowsing::Duration* _msg = _internal_mutable_negative_cache_duration();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+  return _msg;
+}
+inline void FindFullHashesResponse::set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.negative_cache_duration_;
+  }
+  if (negative_cache_duration) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(negative_cache_duration);
+    if (message_arena != submessage_arena) {
+      negative_cache_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, negative_cache_duration, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.negative_cache_duration_ = negative_cache_duration;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatHit_ThreatSource
+
+// optional string url = 1;
+inline bool ThreatHit_ThreatSource::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ThreatHit_ThreatSource::has_url() const {
+  return _internal_has_url();
+}
+inline void ThreatHit_ThreatSource::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ThreatHit_ThreatSource::url() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatHit_ThreatSource::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+}
+inline std::string* ThreatHit_ThreatSource::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+  return _s;
+}
+inline const std::string& ThreatHit_ThreatSource::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ThreatHit_ThreatSource::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatHit_ThreatSource::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatHit_ThreatSource::release_url() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatHit_ThreatSource::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+}
+
+// optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+inline bool ThreatHit_ThreatSource::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ThreatHit_ThreatSource::has_type() const {
+  return _internal_has_type();
+}
+inline void ThreatHit_ThreatSource::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::_internal_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(_impl_.type_);
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.type)
+  return _internal_type();
+}
+inline void ThreatHit_ThreatSource::_internal_set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) {
+  assert(::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.type_ = value;
+}
+inline void ThreatHit_ThreatSource::set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.type)
+}
+
+// optional string remote_ip = 3;
+inline bool ThreatHit_ThreatSource::_internal_has_remote_ip() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ThreatHit_ThreatSource::has_remote_ip() const {
+  return _internal_has_remote_ip();
+}
+inline void ThreatHit_ThreatSource::clear_remote_ip() {
+  _impl_.remote_ip_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ThreatHit_ThreatSource::remote_ip() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+  return _internal_remote_ip();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatHit_ThreatSource::set_remote_ip(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.remote_ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+}
+inline std::string* ThreatHit_ThreatSource::mutable_remote_ip() {
+  std::string* _s = _internal_mutable_remote_ip();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+  return _s;
+}
+inline const std::string& ThreatHit_ThreatSource::_internal_remote_ip() const {
+  return _impl_.remote_ip_.Get();
+}
+inline void ThreatHit_ThreatSource::_internal_set_remote_ip(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.remote_ip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatHit_ThreatSource::_internal_mutable_remote_ip() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.remote_ip_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatHit_ThreatSource::release_remote_ip() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+  if (!_internal_has_remote_ip()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.remote_ip_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remote_ip_.IsDefault()) {
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatHit_ThreatSource::set_allocated_remote_ip(std::string* remote_ip) {
+  if (remote_ip != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.remote_ip_.SetAllocated(remote_ip, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remote_ip_.IsDefault()) {
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+}
+
+// optional string referrer = 4;
+inline bool ThreatHit_ThreatSource::_internal_has_referrer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ThreatHit_ThreatSource::has_referrer() const {
+  return _internal_has_referrer();
+}
+inline void ThreatHit_ThreatSource::clear_referrer() {
+  _impl_.referrer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ThreatHit_ThreatSource::referrer() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+  return _internal_referrer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatHit_ThreatSource::set_referrer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.referrer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+}
+inline std::string* ThreatHit_ThreatSource::mutable_referrer() {
+  std::string* _s = _internal_mutable_referrer();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+  return _s;
+}
+inline const std::string& ThreatHit_ThreatSource::_internal_referrer() const {
+  return _impl_.referrer_.Get();
+}
+inline void ThreatHit_ThreatSource::_internal_set_referrer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.referrer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatHit_ThreatSource::_internal_mutable_referrer() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.referrer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatHit_ThreatSource::release_referrer() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+  if (!_internal_has_referrer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.referrer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_.IsDefault()) {
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatHit_ThreatSource::set_allocated_referrer(std::string* referrer) {
+  if (referrer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.referrer_.SetAllocated(referrer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_.IsDefault()) {
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatHit_UserInfo
+
+// optional string region_code = 1;
+inline bool ThreatHit_UserInfo::_internal_has_region_code() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ThreatHit_UserInfo::has_region_code() const {
+  return _internal_has_region_code();
+}
+inline void ThreatHit_UserInfo::clear_region_code() {
+  _impl_.region_code_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ThreatHit_UserInfo::region_code() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
+  return _internal_region_code();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatHit_UserInfo::set_region_code(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.region_code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
+}
+inline std::string* ThreatHit_UserInfo::mutable_region_code() {
+  std::string* _s = _internal_mutable_region_code();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
+  return _s;
+}
+inline const std::string& ThreatHit_UserInfo::_internal_region_code() const {
+  return _impl_.region_code_.Get();
+}
+inline void ThreatHit_UserInfo::_internal_set_region_code(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.region_code_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatHit_UserInfo::_internal_mutable_region_code() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.region_code_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatHit_UserInfo::release_region_code() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
+  if (!_internal_has_region_code()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.region_code_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.region_code_.IsDefault()) {
+    _impl_.region_code_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatHit_UserInfo::set_allocated_region_code(std::string* region_code) {
+  if (region_code != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.region_code_.SetAllocated(region_code, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.region_code_.IsDefault()) {
+    _impl_.region_code_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.UserInfo.region_code)
+}
+
+// optional bytes user_id = 2;
+inline bool ThreatHit_UserInfo::_internal_has_user_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ThreatHit_UserInfo::has_user_id() const {
+  return _internal_has_user_id();
+}
+inline void ThreatHit_UserInfo::clear_user_id() {
+  _impl_.user_id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ThreatHit_UserInfo::user_id() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
+  return _internal_user_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatHit_UserInfo::set_user_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.user_id_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
+}
+inline std::string* ThreatHit_UserInfo::mutable_user_id() {
+  std::string* _s = _internal_mutable_user_id();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
+  return _s;
+}
+inline const std::string& ThreatHit_UserInfo::_internal_user_id() const {
+  return _impl_.user_id_.Get();
+}
+inline void ThreatHit_UserInfo::_internal_set_user_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.user_id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatHit_UserInfo::_internal_mutable_user_id() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.user_id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatHit_UserInfo::release_user_id() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
+  if (!_internal_has_user_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.user_id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.user_id_.IsDefault()) {
+    _impl_.user_id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatHit_UserInfo::set_allocated_user_id(std::string* user_id) {
+  if (user_id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.user_id_.SetAllocated(user_id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.user_id_.IsDefault()) {
+    _impl_.user_id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.UserInfo.user_id)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatHit
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool ThreatHit::_internal_has_threat_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ThreatHit::has_threat_type() const {
+  return _internal_has_threat_type();
+}
+inline void ThreatHit::clear_threat_type() {
+  _impl_.threat_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatHit::_internal_threat_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_);
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatHit::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.threat_type)
+  return _internal_threat_type();
+}
+inline void ThreatHit::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.threat_type_ = value;
+}
+inline void ThreatHit::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  _internal_set_threat_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool ThreatHit::_internal_has_platform_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ThreatHit::has_platform_type() const {
+  return _internal_has_platform_type();
+}
+inline void ThreatHit::clear_platform_type() {
+  _impl_.platform_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatHit::_internal_platform_type() const {
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_);
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatHit::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.platform_type)
+  return _internal_platform_type();
+}
+inline void ThreatHit::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.platform_type_ = value;
+}
+inline void ThreatHit::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  _internal_set_platform_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+inline bool ThreatHit::_internal_has_entry() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.entry_ != nullptr);
+  return value;
+}
+inline bool ThreatHit::has_entry() const {
+  return _internal_has_entry();
+}
+inline void ThreatHit::clear_entry() {
+  if (_impl_.entry_ != nullptr) _impl_.entry_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::_internal_entry() const {
+  const ::mozilla::safebrowsing::ThreatEntry* p = _impl_.entry_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatEntry&>(
+      ::mozilla::safebrowsing::_ThreatEntry_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::entry() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.entry)
+  return _internal_entry();
+}
+inline void ThreatHit::unsafe_arena_set_allocated_entry(
+    ::mozilla::safebrowsing::ThreatEntry* entry) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_);
+  }
+  _impl_.entry_ = entry;
+  if (entry) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatHit.entry)
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::release_entry() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.entry_;
+  _impl_.entry_ = 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::ThreatEntry* ThreatHit::unsafe_arena_release_entry() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.entry)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::ThreatEntry* temp = _impl_.entry_;
+  _impl_.entry_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::_internal_mutable_entry() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.entry_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatEntry>(GetArenaForAllocation());
+    _impl_.entry_ = p;
+  }
+  return _impl_.entry_;
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::mutable_entry() {
+  ::mozilla::safebrowsing::ThreatEntry* _msg = _internal_mutable_entry();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.entry)
+  return _msg;
+}
+inline void ThreatHit::set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.entry_;
+  }
+  if (entry) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(entry);
+    if (message_arena != submessage_arena) {
+      entry = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, entry, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.entry_ = entry;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.entry)
+}
+
+// repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+inline int ThreatHit::_internal_resources_size() const {
+  return _impl_.resources_.size();
+}
+inline int ThreatHit::resources_size() const {
+  return _internal_resources_size();
+}
+inline void ThreatHit::clear_resources() {
+  _impl_.resources_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::mutable_resources(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.resources)
+  return _impl_.resources_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >*
+ThreatHit::mutable_resources() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatHit.resources)
+  return &_impl_.resources_;
+}
+inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::_internal_resources(int index) const {
+  return _impl_.resources_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::resources(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.resources)
+  return _internal_resources(index);
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::_internal_add_resources() {
+  return _impl_.resources_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::add_resources() {
+  ::mozilla::safebrowsing::ThreatHit_ThreatSource* _add = _internal_add_resources();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatHit.resources)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >&
+ThreatHit::resources() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatHit.resources)
+  return _impl_.resources_;
+}
+
+// optional .mozilla.safebrowsing.ClientInfo client_info = 5;
+inline bool ThreatHit::_internal_has_client_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.client_info_ != nullptr);
+  return value;
+}
+inline bool ThreatHit::has_client_info() const {
+  return _internal_has_client_info();
+}
+inline void ThreatHit::clear_client_info() {
+  if (_impl_.client_info_ != nullptr) _impl_.client_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::ClientInfo& ThreatHit::_internal_client_info() const {
+  const ::mozilla::safebrowsing::ClientInfo* p = _impl_.client_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ClientInfo&>(
+      ::mozilla::safebrowsing::_ClientInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ClientInfo& ThreatHit::client_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.client_info)
+  return _internal_client_info();
+}
+inline void ThreatHit::unsafe_arena_set_allocated_client_info(
+    ::mozilla::safebrowsing::ClientInfo* client_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_info_);
+  }
+  _impl_.client_info_ = client_info;
+  if (client_info) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatHit.client_info)
+}
+inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::release_client_info() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_info_;
+  _impl_.client_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::unsafe_arena_release_client_info() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.client_info)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::ClientInfo* temp = _impl_.client_info_;
+  _impl_.client_info_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::_internal_mutable_client_info() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.client_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ClientInfo>(GetArenaForAllocation());
+    _impl_.client_info_ = p;
+  }
+  return _impl_.client_info_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* ThreatHit::mutable_client_info() {
+  ::mozilla::safebrowsing::ClientInfo* _msg = _internal_mutable_client_info();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.client_info)
+  return _msg;
+}
+inline void ThreatHit::set_allocated_client_info(::mozilla::safebrowsing::ClientInfo* client_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.client_info_;
+  }
+  if (client_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client_info);
+    if (message_arena != submessage_arena) {
+      client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.client_info_ = client_info;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.client_info)
+}
+
+// optional .mozilla.safebrowsing.ThreatHit.UserInfo user_info = 6;
+inline bool ThreatHit::_internal_has_user_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.user_info_ != nullptr);
+  return value;
+}
+inline bool ThreatHit::has_user_info() const {
+  return _internal_has_user_info();
+}
+inline void ThreatHit::clear_user_info() {
+  if (_impl_.user_info_ != nullptr) _impl_.user_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::mozilla::safebrowsing::ThreatHit_UserInfo& ThreatHit::_internal_user_info() const {
+  const ::mozilla::safebrowsing::ThreatHit_UserInfo* p = _impl_.user_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::ThreatHit_UserInfo&>(
+      ::mozilla::safebrowsing::_ThreatHit_UserInfo_default_instance_);
+}
+inline const ::mozilla::safebrowsing::ThreatHit_UserInfo& ThreatHit::user_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.user_info)
+  return _internal_user_info();
+}
+inline void ThreatHit::unsafe_arena_set_allocated_user_info(
+    ::mozilla::safebrowsing::ThreatHit_UserInfo* user_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_info_);
+  }
+  _impl_.user_info_ = user_info;
+  if (user_info) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatHit.user_info)
+}
+inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::release_user_info() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::mozilla::safebrowsing::ThreatHit_UserInfo* temp = _impl_.user_info_;
+  _impl_.user_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::unsafe_arena_release_user_info() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatHit.user_info)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::mozilla::safebrowsing::ThreatHit_UserInfo* temp = _impl_.user_info_;
+  _impl_.user_info_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::_internal_mutable_user_info() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.user_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::ThreatHit_UserInfo>(GetArenaForAllocation());
+    _impl_.user_info_ = p;
+  }
+  return _impl_.user_info_;
+}
+inline ::mozilla::safebrowsing::ThreatHit_UserInfo* ThreatHit::mutable_user_info() {
+  ::mozilla::safebrowsing::ThreatHit_UserInfo* _msg = _internal_mutable_user_info();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.user_info)
+  return _msg;
+}
+inline void ThreatHit::set_allocated_user_info(::mozilla::safebrowsing::ThreatHit_UserInfo* user_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.user_info_;
+  }
+  if (user_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_info);
+    if (message_arena != submessage_arena) {
+      user_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, user_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.user_info_ = user_info;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.user_info)
+}
+
+// -------------------------------------------------------------------
+
+// ClientInfo
+
+// optional string client_id = 1;
+inline bool ClientInfo::_internal_has_client_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientInfo::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline void ClientInfo::clear_client_id() {
+  _impl_.client_id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientInfo::client_id() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_id)
+  return _internal_client_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientInfo::set_client_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.client_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_id)
+}
+inline std::string* ClientInfo::mutable_client_id() {
+  std::string* _s = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_id)
+  return _s;
+}
+inline const std::string& ClientInfo::_internal_client_id() const {
+  return _impl_.client_id_.Get();
+}
+inline void ClientInfo::_internal_set_client_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.client_id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientInfo::_internal_mutable_client_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.client_id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientInfo::release_client_id() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ClientInfo.client_id)
+  if (!_internal_has_client_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.client_id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_id_.IsDefault()) {
+    _impl_.client_id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientInfo::set_allocated_client_id(std::string* client_id) {
+  if (client_id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.client_id_.SetAllocated(client_id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_id_.IsDefault()) {
+    _impl_.client_id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_id)
+}
+
+// optional string client_version = 2;
+inline bool ClientInfo::_internal_has_client_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientInfo::has_client_version() const {
+  return _internal_has_client_version();
+}
+inline void ClientInfo::clear_client_version() {
+  _impl_.client_version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientInfo::client_version() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_version)
+  return _internal_client_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientInfo::set_client_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.client_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_version)
+}
+inline std::string* ClientInfo::mutable_client_version() {
+  std::string* _s = _internal_mutable_client_version();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_version)
+  return _s;
+}
+inline const std::string& ClientInfo::_internal_client_version() const {
+  return _impl_.client_version_.Get();
+}
+inline void ClientInfo::_internal_set_client_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.client_version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientInfo::_internal_mutable_client_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.client_version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientInfo::release_client_version() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ClientInfo.client_version)
+  if (!_internal_has_client_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.client_version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_version_.IsDefault()) {
+    _impl_.client_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientInfo::set_allocated_client_version(std::string* client_version) {
+  if (client_version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.client_version_.SetAllocated(client_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_version_.IsDefault()) {
+    _impl_.client_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_version)
+}
+
+// -------------------------------------------------------------------
+
+// ChromeClientInfo
+
+// optional .mozilla.safebrowsing.ChromeClientInfo.SafeBrowsingReportingPopulation reporting_population = 1;
+inline bool ChromeClientInfo::_internal_has_reporting_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ChromeClientInfo::has_reporting_population() const {
+  return _internal_has_reporting_population();
+}
+inline void ChromeClientInfo::clear_reporting_population() {
+  _impl_.reporting_population_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::_internal_reporting_population() const {
+  return static_cast< ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation >(_impl_.reporting_population_);
+}
+inline ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation ChromeClientInfo::reporting_population() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ChromeClientInfo.reporting_population)
+  return _internal_reporting_population();
+}
+inline void ChromeClientInfo::_internal_set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value) {
+  assert(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.reporting_population_ = value;
+}
+inline void ChromeClientInfo::set_reporting_population(::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation value) {
+  _internal_set_reporting_population(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ChromeClientInfo.reporting_population)
+}
+
+// -------------------------------------------------------------------
+
+// Checksum
+
+// optional bytes sha256 = 1;
+inline bool Checksum::_internal_has_sha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Checksum::has_sha256() const {
+  return _internal_has_sha256();
+}
+inline void Checksum::clear_sha256() {
+  _impl_.sha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Checksum::sha256() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Checksum.sha256)
+  return _internal_sha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Checksum::set_sha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.sha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Checksum.sha256)
+}
+inline std::string* Checksum::mutable_sha256() {
+  std::string* _s = _internal_mutable_sha256();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.Checksum.sha256)
+  return _s;
+}
+inline const std::string& Checksum::_internal_sha256() const {
+  return _impl_.sha256_.Get();
+}
+inline void Checksum::_internal_set_sha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.sha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Checksum::_internal_mutable_sha256() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.sha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Checksum::release_sha256() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.Checksum.sha256)
+  if (!_internal_has_sha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.sha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sha256_.IsDefault()) {
+    _impl_.sha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Checksum::set_allocated_sha256(std::string* sha256) {
+  if (sha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.sha256_.SetAllocated(sha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sha256_.IsDefault()) {
+    _impl_.sha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.Checksum.sha256)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntry
+
+// optional bytes hash = 1;
+inline bool ThreatEntry::_internal_has_hash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ThreatEntry::has_hash() const {
+  return _internal_has_hash();
+}
+inline void ThreatEntry::clear_hash() {
+  _impl_.hash_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ThreatEntry::hash() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.hash)
+  return _internal_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatEntry::set_hash(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.hash)
+}
+inline std::string* ThreatEntry::mutable_hash() {
+  std::string* _s = _internal_mutable_hash();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.hash)
+  return _s;
+}
+inline const std::string& ThreatEntry::_internal_hash() const {
+  return _impl_.hash_.Get();
+}
+inline void ThreatEntry::_internal_set_hash(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatEntry::_internal_mutable_hash() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatEntry::release_hash() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntry.hash)
+  if (!_internal_has_hash()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.hash_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatEntry::set_allocated_hash(std::string* hash) {
+  if (hash != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.hash)
+}
+
+// optional string url = 2;
+inline bool ThreatEntry::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ThreatEntry::has_url() const {
+  return _internal_has_url();
+}
+inline void ThreatEntry::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ThreatEntry::url() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatEntry::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.url)
+}
+inline std::string* ThreatEntry::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.url)
+  return _s;
+}
+inline const std::string& ThreatEntry::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ThreatEntry::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatEntry::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatEntry::release_url() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntry.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatEntry::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.url)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntrySet
+
+// optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+inline bool ThreatEntrySet::_internal_has_compression_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ThreatEntrySet::has_compression_type() const {
+  return _internal_has_compression_type();
+}
+inline void ThreatEntrySet::clear_compression_type() {
+  _impl_.compression_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::_internal_compression_type() const {
+  return static_cast< ::mozilla::safebrowsing::CompressionType >(_impl_.compression_type_);
+}
+inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::compression_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.compression_type)
+  return _internal_compression_type();
+}
+inline void ThreatEntrySet::_internal_set_compression_type(::mozilla::safebrowsing::CompressionType value) {
+  assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.compression_type_ = value;
+}
+inline void ThreatEntrySet::set_compression_type(::mozilla::safebrowsing::CompressionType value) {
+  _internal_set_compression_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntrySet.compression_type)
+}
+
+// optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+inline bool ThreatEntrySet::_internal_has_raw_hashes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.raw_hashes_ != nullptr);
+  return value;
+}
+inline bool ThreatEntrySet::has_raw_hashes() const {
+  return _internal_has_raw_hashes();
+}
+inline void ThreatEntrySet::clear_raw_hashes() {
+  if (_impl_.raw_hashes_ != nullptr) _impl_.raw_hashes_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::_internal_raw_hashes() const {
+  const ::mozilla::safebrowsing::RawHashes* p = _impl_.raw_hashes_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RawHashes&>(
+      ::mozilla::safebrowsing::_RawHashes_default_instance_);
+}
+inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::raw_hashes() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+  return _internal_raw_hashes();
+}
+inline void ThreatEntrySet::unsafe_arena_set_allocated_raw_hashes(
+    ::mozilla::safebrowsing::RawHashes* raw_hashes) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.raw_hashes_);
+  }
+  _impl_.raw_hashes_ = raw_hashes;
+  if (raw_hashes) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+}
+inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::release_raw_hashes() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::RawHashes* temp = _impl_.raw_hashes_;
+  _impl_.raw_hashes_ = 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::RawHashes* ThreatEntrySet::unsafe_arena_release_raw_hashes() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::mozilla::safebrowsing::RawHashes* temp = _impl_.raw_hashes_;
+  _impl_.raw_hashes_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::_internal_mutable_raw_hashes() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.raw_hashes_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RawHashes>(GetArenaForAllocation());
+    _impl_.raw_hashes_ = p;
+  }
+  return _impl_.raw_hashes_;
+}
+inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::mutable_raw_hashes() {
+  ::mozilla::safebrowsing::RawHashes* _msg = _internal_mutable_raw_hashes();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+  return _msg;
+}
+inline void ThreatEntrySet::set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.raw_hashes_;
+  }
+  if (raw_hashes) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_hashes);
+    if (message_arena != submessage_arena) {
+      raw_hashes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, raw_hashes, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.raw_hashes_ = raw_hashes;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+}
+
+// optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+inline bool ThreatEntrySet::_internal_has_raw_indices() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.raw_indices_ != nullptr);
+  return value;
+}
+inline bool ThreatEntrySet::has_raw_indices() const {
+  return _internal_has_raw_indices();
+}
+inline void ThreatEntrySet::clear_raw_indices() {
+  if (_impl_.raw_indices_ != nullptr) _impl_.raw_indices_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::_internal_raw_indices() const {
+  const ::mozilla::safebrowsing::RawIndices* p = _impl_.raw_indices_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RawIndices&>(
+      ::mozilla::safebrowsing::_RawIndices_default_instance_);
+}
+inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::raw_indices() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+  return _internal_raw_indices();
+}
+inline void ThreatEntrySet::unsafe_arena_set_allocated_raw_indices(
+    ::mozilla::safebrowsing::RawIndices* raw_indices) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.raw_indices_);
+  }
+  _impl_.raw_indices_ = raw_indices;
+  if (raw_indices) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+}
+inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::release_raw_indices() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::RawIndices* temp = _impl_.raw_indices_;
+  _impl_.raw_indices_ = 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::RawIndices* ThreatEntrySet::unsafe_arena_release_raw_indices() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::mozilla::safebrowsing::RawIndices* temp = _impl_.raw_indices_;
+  _impl_.raw_indices_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::_internal_mutable_raw_indices() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.raw_indices_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RawIndices>(GetArenaForAllocation());
+    _impl_.raw_indices_ = p;
+  }
+  return _impl_.raw_indices_;
+}
+inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::mutable_raw_indices() {
+  ::mozilla::safebrowsing::RawIndices* _msg = _internal_mutable_raw_indices();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+  return _msg;
+}
+inline void ThreatEntrySet::set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.raw_indices_;
+  }
+  if (raw_indices) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_indices);
+    if (message_arena != submessage_arena) {
+      raw_indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, raw_indices, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.raw_indices_ = raw_indices;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+}
+
+// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+inline bool ThreatEntrySet::_internal_has_rice_hashes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.rice_hashes_ != nullptr);
+  return value;
+}
+inline bool ThreatEntrySet::has_rice_hashes() const {
+  return _internal_has_rice_hashes();
+}
+inline void ThreatEntrySet::clear_rice_hashes() {
+  if (_impl_.rice_hashes_ != nullptr) _impl_.rice_hashes_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::_internal_rice_hashes() const {
+  const ::mozilla::safebrowsing::RiceDeltaEncoding* p = _impl_.rice_hashes_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RiceDeltaEncoding&>(
+      ::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_);
+}
+inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_hashes() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+  return _internal_rice_hashes();
+}
+inline void ThreatEntrySet::unsafe_arena_set_allocated_rice_hashes(
+    ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rice_hashes_);
+  }
+  _impl_.rice_hashes_ = rice_hashes;
+  if (rice_hashes) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_hashes() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_hashes_;
+  _impl_.rice_hashes_ = 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::RiceDeltaEncoding* ThreatEntrySet::unsafe_arena_release_rice_hashes() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_hashes_;
+  _impl_.rice_hashes_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::_internal_mutable_rice_hashes() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.rice_hashes_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(GetArenaForAllocation());
+    _impl_.rice_hashes_ = p;
+  }
+  return _impl_.rice_hashes_;
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_hashes() {
+  ::mozilla::safebrowsing::RiceDeltaEncoding* _msg = _internal_mutable_rice_hashes();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+  return _msg;
+}
+inline void ThreatEntrySet::set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.rice_hashes_;
+  }
+  if (rice_hashes) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rice_hashes);
+    if (message_arena != submessage_arena) {
+      rice_hashes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, rice_hashes, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.rice_hashes_ = rice_hashes;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+}
+
+// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+inline bool ThreatEntrySet::_internal_has_rice_indices() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.rice_indices_ != nullptr);
+  return value;
+}
+inline bool ThreatEntrySet::has_rice_indices() const {
+  return _internal_has_rice_indices();
+}
+inline void ThreatEntrySet::clear_rice_indices() {
+  if (_impl_.rice_indices_ != nullptr) _impl_.rice_indices_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::_internal_rice_indices() const {
+  const ::mozilla::safebrowsing::RiceDeltaEncoding* p = _impl_.rice_indices_;
+  return p != nullptr ? *p : reinterpret_cast<const ::mozilla::safebrowsing::RiceDeltaEncoding&>(
+      ::mozilla::safebrowsing::_RiceDeltaEncoding_default_instance_);
+}
+inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_indices() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+  return _internal_rice_indices();
+}
+inline void ThreatEntrySet::unsafe_arena_set_allocated_rice_indices(
+    ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rice_indices_);
+  }
+  _impl_.rice_indices_ = rice_indices;
+  if (rice_indices) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_indices() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_indices_;
+  _impl_.rice_indices_ = 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::RiceDeltaEncoding* ThreatEntrySet::unsafe_arena_release_rice_indices() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* temp = _impl_.rice_indices_;
+  _impl_.rice_indices_ = nullptr;
+  return temp;
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::_internal_mutable_rice_indices() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.rice_indices_ == nullptr) {
+    auto* p = CreateMaybeMessage<::mozilla::safebrowsing::RiceDeltaEncoding>(GetArenaForAllocation());
+    _impl_.rice_indices_ = p;
+  }
+  return _impl_.rice_indices_;
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_indices() {
+  ::mozilla::safebrowsing::RiceDeltaEncoding* _msg = _internal_mutable_rice_indices();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+  return _msg;
+}
+inline void ThreatEntrySet::set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.rice_indices_;
+  }
+  if (rice_indices) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rice_indices);
+    if (message_arena != submessage_arena) {
+      rice_indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, rice_indices, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.rice_indices_ = rice_indices;
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+}
+
+// -------------------------------------------------------------------
+
+// RawIndices
+
+// repeated int32 indices = 1;
+inline int RawIndices::_internal_indices_size() const {
+  return _impl_.indices_.size();
+}
+inline int RawIndices::indices_size() const {
+  return _internal_indices_size();
+}
+inline void RawIndices::clear_indices() {
+  _impl_.indices_.Clear();
+}
+inline int32_t RawIndices::_internal_indices(int index) const {
+  return _impl_.indices_.Get(index);
+}
+inline int32_t RawIndices::indices(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawIndices.indices)
+  return _internal_indices(index);
+}
+inline void RawIndices::set_indices(int index, int32_t value) {
+  _impl_.indices_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawIndices.indices)
+}
+inline void RawIndices::_internal_add_indices(int32_t value) {
+  _impl_.indices_.Add(value);
+}
+inline void RawIndices::add_indices(int32_t value) {
+  _internal_add_indices(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.RawIndices.indices)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+RawIndices::_internal_indices() const {
+  return _impl_.indices_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+RawIndices::indices() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.RawIndices.indices)
+  return _internal_indices();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+RawIndices::_internal_mutable_indices() {
+  return &_impl_.indices_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+RawIndices::mutable_indices() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.RawIndices.indices)
+  return _internal_mutable_indices();
+}
+
+// -------------------------------------------------------------------
+
+// RawHashes
+
+// optional int32 prefix_size = 1;
+inline bool RawHashes::_internal_has_prefix_size() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RawHashes::has_prefix_size() const {
+  return _internal_has_prefix_size();
+}
+inline void RawHashes::clear_prefix_size() {
+  _impl_.prefix_size_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t RawHashes::_internal_prefix_size() const {
+  return _impl_.prefix_size_;
+}
+inline int32_t RawHashes::prefix_size() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.prefix_size)
+  return _internal_prefix_size();
+}
+inline void RawHashes::_internal_set_prefix_size(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.prefix_size_ = value;
+}
+inline void RawHashes::set_prefix_size(int32_t value) {
+  _internal_set_prefix_size(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.prefix_size)
+}
+
+// optional bytes raw_hashes = 2;
+inline bool RawHashes::_internal_has_raw_hashes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RawHashes::has_raw_hashes() const {
+  return _internal_has_raw_hashes();
+}
+inline void RawHashes::clear_raw_hashes() {
+  _impl_.raw_hashes_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RawHashes::raw_hashes() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.raw_hashes)
+  return _internal_raw_hashes();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RawHashes::set_raw_hashes(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.raw_hashes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.raw_hashes)
+}
+inline std::string* RawHashes::mutable_raw_hashes() {
+  std::string* _s = _internal_mutable_raw_hashes();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RawHashes.raw_hashes)
+  return _s;
+}
+inline const std::string& RawHashes::_internal_raw_hashes() const {
+  return _impl_.raw_hashes_.Get();
+}
+inline void RawHashes::_internal_set_raw_hashes(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.raw_hashes_.Set(value, GetArenaForAllocation());
+}
+inline std::string* RawHashes::_internal_mutable_raw_hashes() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.raw_hashes_.Mutable(GetArenaForAllocation());
+}
+inline std::string* RawHashes::release_raw_hashes() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.RawHashes.raw_hashes)
+  if (!_internal_has_raw_hashes()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.raw_hashes_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.raw_hashes_.IsDefault()) {
+    _impl_.raw_hashes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void RawHashes::set_allocated_raw_hashes(std::string* raw_hashes) {
+  if (raw_hashes != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.raw_hashes_.SetAllocated(raw_hashes, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.raw_hashes_.IsDefault()) {
+    _impl_.raw_hashes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RawHashes.raw_hashes)
+}
+
+// -------------------------------------------------------------------
+
+// RiceDeltaEncoding
+
+// optional int64 first_value = 1;
+inline bool RiceDeltaEncoding::_internal_has_first_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RiceDeltaEncoding::has_first_value() const {
+  return _internal_has_first_value();
+}
+inline void RiceDeltaEncoding::clear_first_value() {
+  _impl_.first_value_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t RiceDeltaEncoding::_internal_first_value() const {
+  return _impl_.first_value_;
+}
+inline int64_t RiceDeltaEncoding::first_value() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.first_value)
+  return _internal_first_value();
+}
+inline void RiceDeltaEncoding::_internal_set_first_value(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.first_value_ = value;
+}
+inline void RiceDeltaEncoding::set_first_value(int64_t value) {
+  _internal_set_first_value(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.first_value)
+}
+
+// optional int32 rice_parameter = 2;
+inline bool RiceDeltaEncoding::_internal_has_rice_parameter() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool RiceDeltaEncoding::has_rice_parameter() const {
+  return _internal_has_rice_parameter();
+}
+inline void RiceDeltaEncoding::clear_rice_parameter() {
+  _impl_.rice_parameter_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t RiceDeltaEncoding::_internal_rice_parameter() const {
+  return _impl_.rice_parameter_;
+}
+inline int32_t RiceDeltaEncoding::rice_parameter() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter)
+  return _internal_rice_parameter();
+}
+inline void RiceDeltaEncoding::_internal_set_rice_parameter(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.rice_parameter_ = value;
+}
+inline void RiceDeltaEncoding::set_rice_parameter(int32_t value) {
+  _internal_set_rice_parameter(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter)
+}
+
+// optional int32 num_entries = 3;
+inline bool RiceDeltaEncoding::_internal_has_num_entries() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool RiceDeltaEncoding::has_num_entries() const {
+  return _internal_has_num_entries();
+}
+inline void RiceDeltaEncoding::clear_num_entries() {
+  _impl_.num_entries_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t RiceDeltaEncoding::_internal_num_entries() const {
+  return _impl_.num_entries_;
+}
+inline int32_t RiceDeltaEncoding::num_entries() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.num_entries)
+  return _internal_num_entries();
+}
+inline void RiceDeltaEncoding::_internal_set_num_entries(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.num_entries_ = value;
+}
+inline void RiceDeltaEncoding::set_num_entries(int32_t value) {
+  _internal_set_num_entries(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.num_entries)
+}
+
+// optional bytes encoded_data = 4;
+inline bool RiceDeltaEncoding::_internal_has_encoded_data() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RiceDeltaEncoding::has_encoded_data() const {
+  return _internal_has_encoded_data();
+}
+inline void RiceDeltaEncoding::clear_encoded_data() {
+  _impl_.encoded_data_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RiceDeltaEncoding::encoded_data() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+  return _internal_encoded_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RiceDeltaEncoding::set_encoded_data(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.encoded_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+}
+inline std::string* RiceDeltaEncoding::mutable_encoded_data() {
+  std::string* _s = _internal_mutable_encoded_data();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+  return _s;
+}
+inline const std::string& RiceDeltaEncoding::_internal_encoded_data() const {
+  return _impl_.encoded_data_.Get();
+}
+inline void RiceDeltaEncoding::_internal_set_encoded_data(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.encoded_data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* RiceDeltaEncoding::_internal_mutable_encoded_data() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.encoded_data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* RiceDeltaEncoding::release_encoded_data() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+  if (!_internal_has_encoded_data()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.encoded_data_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encoded_data_.IsDefault()) {
+    _impl_.encoded_data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void RiceDeltaEncoding::set_allocated_encoded_data(std::string* encoded_data) {
+  if (encoded_data != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _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.RiceDeltaEncoding.encoded_data)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntryMetadata_MetadataEntry
+
+// optional bytes key = 1;
+inline bool ThreatEntryMetadata_MetadataEntry::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ThreatEntryMetadata_MetadataEntry::has_key() const {
+  return _internal_has_key();
+}
+inline void ThreatEntryMetadata_MetadataEntry::clear_key() {
+  _impl_.key_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ThreatEntryMetadata_MetadataEntry::key() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatEntryMetadata_MetadataEntry::set_key(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+}
+inline std::string* ThreatEntryMetadata_MetadataEntry::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+  return _s;
+}
+inline const std::string& ThreatEntryMetadata_MetadataEntry::_internal_key() const {
+  return _impl_.key_.Get();
+}
+inline void ThreatEntryMetadata_MetadataEntry::_internal_set_key(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.key_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatEntryMetadata_MetadataEntry::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.key_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatEntryMetadata_MetadataEntry::release_key() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.key_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+}
+
+// optional bytes value = 2;
+inline bool ThreatEntryMetadata_MetadataEntry::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ThreatEntryMetadata_MetadataEntry::has_value() const {
+  return _internal_has_value();
+}
+inline void ThreatEntryMetadata_MetadataEntry::clear_value() {
+  _impl_.value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ThreatEntryMetadata_MetadataEntry::value() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ThreatEntryMetadata_MetadataEntry::set_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+}
+inline std::string* ThreatEntryMetadata_MetadataEntry::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+  return _s;
+}
+inline const std::string& ThreatEntryMetadata_MetadataEntry::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void ThreatEntryMetadata_MetadataEntry::_internal_set_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ThreatEntryMetadata_MetadataEntry::_internal_mutable_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ThreatEntryMetadata_MetadataEntry::release_value() {
+  // @@protoc_insertion_point(field_release:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+  if (!_internal_has_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntryMetadata
+
+// repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+inline int ThreatEntryMetadata::_internal_entries_size() const {
+  return _impl_.entries_.size();
+}
+inline int ThreatEntryMetadata::entries_size() const {
+  return _internal_entries_size();
+}
+inline void ThreatEntryMetadata::clear_entries() {
+  _impl_.entries_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::mutable_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return _impl_.entries_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >*
+ThreatEntryMetadata::mutable_entries() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return &_impl_.entries_;
+}
+inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::_internal_entries(int index) const {
+  return _impl_.entries_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::entries(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return _internal_entries(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::_internal_add_entries() {
+  return _impl_.entries_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::add_entries() {
+  ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* _add = _internal_add_entries();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >&
+ThreatEntryMetadata::entries() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return _impl_.entries_;
+}
+
+// -------------------------------------------------------------------
+
+// ThreatListDescriptor
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool ThreatListDescriptor::_internal_has_threat_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ThreatListDescriptor::has_threat_type() const {
+  return _internal_has_threat_type();
+}
+inline void ThreatListDescriptor::clear_threat_type() {
+  _impl_.threat_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::_internal_threat_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(_impl_.threat_type_);
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_type)
+  return _internal_threat_type();
+}
+inline void ThreatListDescriptor::_internal_set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.threat_type_ = value;
+}
+inline void ThreatListDescriptor::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  _internal_set_threat_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool ThreatListDescriptor::_internal_has_platform_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ThreatListDescriptor::has_platform_type() const {
+  return _internal_has_platform_type();
+}
+inline void ThreatListDescriptor::clear_platform_type() {
+  _impl_.platform_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::_internal_platform_type() const {
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(_impl_.platform_type_);
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.platform_type)
+  return _internal_platform_type();
+}
+inline void ThreatListDescriptor::_internal_set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.platform_type_ = value;
+}
+inline void ThreatListDescriptor::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  _internal_set_platform_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+inline bool ThreatListDescriptor::_internal_has_threat_entry_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ThreatListDescriptor::has_threat_entry_type() const {
+  return _internal_has_threat_entry_type();
+}
+inline void ThreatListDescriptor::clear_threat_entry_type() {
+  _impl_.threat_entry_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::_internal_threat_entry_type() const {
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(_impl_.threat_entry_type_);
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type)
+  return _internal_threat_entry_type();
+}
+inline void ThreatListDescriptor::_internal_set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.threat_entry_type_ = value;
+}
+inline void ThreatListDescriptor::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  _internal_set_threat_entry_type(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type)
+}
+
+// -------------------------------------------------------------------
+
+// ListThreatListsResponse
+
+// repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+inline int ListThreatListsResponse::_internal_threat_lists_size() const {
+  return _impl_.threat_lists_.size();
+}
+inline int ListThreatListsResponse::threat_lists_size() const {
+  return _internal_threat_lists_size();
+}
+inline void ListThreatListsResponse::clear_threat_lists() {
+  _impl_.threat_lists_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::mutable_threat_lists(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return _impl_.threat_lists_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >*
+ListThreatListsResponse::mutable_threat_lists() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return &_impl_.threat_lists_;
+}
+inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::_internal_threat_lists(int index) const {
+  return _impl_.threat_lists_.Get(index);
+}
+inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::threat_lists(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return _internal_threat_lists(index);
+}
+inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::_internal_add_threat_lists() {
+  return _impl_.threat_lists_.Add();
+}
+inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::add_threat_lists() {
+  ::mozilla::safebrowsing::ThreatListDescriptor* _add = _internal_add_threat_lists();
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >&
+ListThreatListsResponse::threat_lists() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return _impl_.threat_lists_;
+}
+
+// -------------------------------------------------------------------
+
+// Duration
+
+// optional int64 seconds = 1;
+inline bool Duration::_internal_has_seconds() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Duration::has_seconds() const {
+  return _internal_has_seconds();
+}
+inline void Duration::clear_seconds() {
+  _impl_.seconds_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t Duration::_internal_seconds() const {
+  return _impl_.seconds_;
+}
+inline int64_t Duration::seconds() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.seconds)
+  return _internal_seconds();
+}
+inline void Duration::_internal_set_seconds(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.seconds_ = value;
+}
+inline void Duration::set_seconds(int64_t value) {
+  _internal_set_seconds(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.seconds)
+}
+
+// optional int32 nanos = 2;
+inline bool Duration::_internal_has_nanos() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Duration::has_nanos() const {
+  return _internal_has_nanos();
+}
+inline void Duration::clear_nanos() {
+  _impl_.nanos_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t Duration::_internal_nanos() const {
+  return _impl_.nanos_;
+}
+inline int32_t Duration::nanos() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.nanos)
+  return _internal_nanos();
+}
+inline void Duration::_internal_set_nanos(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.nanos_ = value;
+}
+inline void Duration::set_nanos(int32_t value) {
+  _internal_set_nanos(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.nanos)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace safebrowsing
+}  // namespace mozilla
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType> : ::std::true_type {};
+template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType> : ::std::true_type {};
+template <> struct is_proto_enum< ::mozilla::safebrowsing::ChromeClientInfo_SafeBrowsingReportingPopulation> : ::std::true_type {};
+template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatType> : ::std::true_type {};
+template <> struct is_proto_enum< ::mozilla::safebrowsing::PlatformType> : ::std::true_type {};
+template <> struct is_proto_enum< ::mozilla::safebrowsing::CompressionType> : ::std::true_type {};
+template <> struct is_proto_enum< ::mozilla::safebrowsing::ThreatEntryType> : ::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_2eproto