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

#ifndef GOOGLE_PROTOBUF_INCLUDED_download_5ffile_5ftypes_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_download_5ffile_5ftypes_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#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 3009000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.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_download_5ffile_5ftypes_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_download_5ffile_5ftypes_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace safe_browsing {
class DownloadFileType;
class DownloadFileTypeDefaultTypeInternal;
extern DownloadFileTypeDefaultTypeInternal _DownloadFileType_default_instance_;
class DownloadFileTypeConfig;
class DownloadFileTypeConfigDefaultTypeInternal;
extern DownloadFileTypeConfigDefaultTypeInternal _DownloadFileTypeConfig_default_instance_;
class DownloadFileType_PlatformSettings;
class DownloadFileType_PlatformSettingsDefaultTypeInternal;
extern DownloadFileType_PlatformSettingsDefaultTypeInternal _DownloadFileType_PlatformSettings_default_instance_;
}  // namespace safe_browsing
PROTOBUF_NAMESPACE_OPEN
template<> ::safe_browsing::DownloadFileType* Arena::CreateMaybeMessage<::safe_browsing::DownloadFileType>(Arena*);
template<> ::safe_browsing::DownloadFileTypeConfig* Arena::CreateMaybeMessage<::safe_browsing::DownloadFileTypeConfig>(Arena*);
template<> ::safe_browsing::DownloadFileType_PlatformSettings* Arena::CreateMaybeMessage<::safe_browsing::DownloadFileType_PlatformSettings>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace safe_browsing {

enum DownloadFileType_PingSetting : int {
  DownloadFileType_PingSetting_SAMPLED_PING = 0,
  DownloadFileType_PingSetting_NO_PING = 1,
  DownloadFileType_PingSetting_FULL_PING = 2
};
bool DownloadFileType_PingSetting_IsValid(int value);
constexpr DownloadFileType_PingSetting DownloadFileType_PingSetting_PingSetting_MIN = DownloadFileType_PingSetting_SAMPLED_PING;
constexpr DownloadFileType_PingSetting DownloadFileType_PingSetting_PingSetting_MAX = DownloadFileType_PingSetting_FULL_PING;
constexpr int DownloadFileType_PingSetting_PingSetting_ARRAYSIZE = DownloadFileType_PingSetting_PingSetting_MAX + 1;

const std::string& DownloadFileType_PingSetting_Name(DownloadFileType_PingSetting value);
template<typename T>
inline const std::string& DownloadFileType_PingSetting_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DownloadFileType_PingSetting>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DownloadFileType_PingSetting_Name.");
  return DownloadFileType_PingSetting_Name(static_cast<DownloadFileType_PingSetting>(enum_t_value));
}
bool DownloadFileType_PingSetting_Parse(
    const std::string& name, DownloadFileType_PingSetting* value);
enum DownloadFileType_DangerLevel : int {
  DownloadFileType_DangerLevel_NOT_DANGEROUS = 0,
  DownloadFileType_DangerLevel_ALLOW_ON_USER_GESTURE = 1,
  DownloadFileType_DangerLevel_DANGEROUS = 2
};
bool DownloadFileType_DangerLevel_IsValid(int value);
constexpr DownloadFileType_DangerLevel DownloadFileType_DangerLevel_DangerLevel_MIN = DownloadFileType_DangerLevel_NOT_DANGEROUS;
constexpr DownloadFileType_DangerLevel DownloadFileType_DangerLevel_DangerLevel_MAX = DownloadFileType_DangerLevel_DANGEROUS;
constexpr int DownloadFileType_DangerLevel_DangerLevel_ARRAYSIZE = DownloadFileType_DangerLevel_DangerLevel_MAX + 1;

const std::string& DownloadFileType_DangerLevel_Name(DownloadFileType_DangerLevel value);
template<typename T>
inline const std::string& DownloadFileType_DangerLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DownloadFileType_DangerLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DownloadFileType_DangerLevel_Name.");
  return DownloadFileType_DangerLevel_Name(static_cast<DownloadFileType_DangerLevel>(enum_t_value));
}
bool DownloadFileType_DangerLevel_Parse(
    const std::string& name, DownloadFileType_DangerLevel* value);
enum DownloadFileType_AutoOpenHint : int {
  DownloadFileType_AutoOpenHint_DISALLOW_AUTO_OPEN = 0,
  DownloadFileType_AutoOpenHint_ALLOW_AUTO_OPEN = 1
};
bool DownloadFileType_AutoOpenHint_IsValid(int value);
constexpr DownloadFileType_AutoOpenHint DownloadFileType_AutoOpenHint_AutoOpenHint_MIN = DownloadFileType_AutoOpenHint_DISALLOW_AUTO_OPEN;
constexpr DownloadFileType_AutoOpenHint DownloadFileType_AutoOpenHint_AutoOpenHint_MAX = DownloadFileType_AutoOpenHint_ALLOW_AUTO_OPEN;
constexpr int DownloadFileType_AutoOpenHint_AutoOpenHint_ARRAYSIZE = DownloadFileType_AutoOpenHint_AutoOpenHint_MAX + 1;

const std::string& DownloadFileType_AutoOpenHint_Name(DownloadFileType_AutoOpenHint value);
template<typename T>
inline const std::string& DownloadFileType_AutoOpenHint_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DownloadFileType_AutoOpenHint>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DownloadFileType_AutoOpenHint_Name.");
  return DownloadFileType_AutoOpenHint_Name(static_cast<DownloadFileType_AutoOpenHint>(enum_t_value));
}
bool DownloadFileType_AutoOpenHint_Parse(
    const std::string& name, DownloadFileType_AutoOpenHint* value);
enum DownloadFileType_PlatformType : int {
  DownloadFileType_PlatformType_PLATFORM_ANY = 0,
  DownloadFileType_PlatformType_PLATFORM_ANDROID = 1,
  DownloadFileType_PlatformType_PLATFORM_CHROME_OS = 2,
  DownloadFileType_PlatformType_PLATFORM_LINUX = 3,
  DownloadFileType_PlatformType_PLATFORM_MAC = 4,
  DownloadFileType_PlatformType_PLATFORM_WINDOWS = 5
};
bool DownloadFileType_PlatformType_IsValid(int value);
constexpr DownloadFileType_PlatformType DownloadFileType_PlatformType_PlatformType_MIN = DownloadFileType_PlatformType_PLATFORM_ANY;
constexpr DownloadFileType_PlatformType DownloadFileType_PlatformType_PlatformType_MAX = DownloadFileType_PlatformType_PLATFORM_WINDOWS;
constexpr int DownloadFileType_PlatformType_PlatformType_ARRAYSIZE = DownloadFileType_PlatformType_PlatformType_MAX + 1;

const std::string& DownloadFileType_PlatformType_Name(DownloadFileType_PlatformType value);
template<typename T>
inline const std::string& DownloadFileType_PlatformType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DownloadFileType_PlatformType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DownloadFileType_PlatformType_Name.");
  return DownloadFileType_PlatformType_Name(static_cast<DownloadFileType_PlatformType>(enum_t_value));
}
bool DownloadFileType_PlatformType_Parse(
    const std::string& name, DownloadFileType_PlatformType* value);
enum DownloadFileType_InspectionType : int {
  DownloadFileType_InspectionType_NONE = 0,
  DownloadFileType_InspectionType_ZIP = 1,
  DownloadFileType_InspectionType_RAR = 2,
  DownloadFileType_InspectionType_DMG = 3
};
bool DownloadFileType_InspectionType_IsValid(int value);
constexpr DownloadFileType_InspectionType DownloadFileType_InspectionType_InspectionType_MIN = DownloadFileType_InspectionType_NONE;
constexpr DownloadFileType_InspectionType DownloadFileType_InspectionType_InspectionType_MAX = DownloadFileType_InspectionType_DMG;
constexpr int DownloadFileType_InspectionType_InspectionType_ARRAYSIZE = DownloadFileType_InspectionType_InspectionType_MAX + 1;

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

class DownloadFileType_PlatformSettings :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DownloadFileType.PlatformSettings) */ {
 public:
  DownloadFileType_PlatformSettings();
  virtual ~DownloadFileType_PlatformSettings();

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

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

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const DownloadFileType_PlatformSettings& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DownloadFileType_PlatformSettings* internal_default_instance() {
    return reinterpret_cast<const DownloadFileType_PlatformSettings*>(
               &_DownloadFileType_PlatformSettings_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(DownloadFileType_PlatformSettings& a, DownloadFileType_PlatformSettings& b) {
    a.Swap(&b);
  }
  inline void Swap(DownloadFileType_PlatformSettings* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline DownloadFileType_PlatformSettings* New() const final {
    return CreateMaybeMessage<DownloadFileType_PlatformSettings>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DownloadFileType_PlatformSettings* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "safe_browsing.DownloadFileType.PlatformSettings";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kPlatformFieldNumber = 1,
    kDangerLevelFieldNumber = 2,
    kAutoOpenHintFieldNumber = 3,
    kMaxFileSizeToAnalyzeFieldNumber = 4,
  };
  // optional .safe_browsing.DownloadFileType.PlatformType platform = 1 [default = PLATFORM_ANY];
  bool has_platform() const;
  void clear_platform();
  ::safe_browsing::DownloadFileType_PlatformType platform() const;
  void set_platform(::safe_browsing::DownloadFileType_PlatformType value);

  // optional .safe_browsing.DownloadFileType.DangerLevel danger_level = 2;
  bool has_danger_level() const;
  void clear_danger_level();
  ::safe_browsing::DownloadFileType_DangerLevel danger_level() const;
  void set_danger_level(::safe_browsing::DownloadFileType_DangerLevel value);

  // optional .safe_browsing.DownloadFileType.AutoOpenHint auto_open_hint = 3;
  bool has_auto_open_hint() const;
  void clear_auto_open_hint();
  ::safe_browsing::DownloadFileType_AutoOpenHint auto_open_hint() const;
  void set_auto_open_hint(::safe_browsing::DownloadFileType_AutoOpenHint value);

  // optional uint64 max_file_size_to_analyze = 4 [default = 18446744073709551615];
  bool has_max_file_size_to_analyze() const;
  void clear_max_file_size_to_analyze();
  ::PROTOBUF_NAMESPACE_ID::uint64 max_file_size_to_analyze() const;
  void set_max_file_size_to_analyze(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:safe_browsing.DownloadFileType.PlatformSettings)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int platform_;
  int danger_level_;
  int auto_open_hint_;
  ::PROTOBUF_NAMESPACE_ID::uint64 max_file_size_to_analyze_;
  friend struct ::TableStruct_download_5ffile_5ftypes_2eproto;
};
// -------------------------------------------------------------------

class DownloadFileType :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DownloadFileType) */ {
 public:
  DownloadFileType();
  virtual ~DownloadFileType();

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

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

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const DownloadFileType& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DownloadFileType* internal_default_instance() {
    return reinterpret_cast<const DownloadFileType*>(
               &_DownloadFileType_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(DownloadFileType& a, DownloadFileType& b) {
    a.Swap(&b);
  }
  inline void Swap(DownloadFileType* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline DownloadFileType* New() const final {
    return CreateMaybeMessage<DownloadFileType>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DownloadFileType* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "safe_browsing.DownloadFileType";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

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

  typedef DownloadFileType_PlatformSettings PlatformSettings;

  typedef DownloadFileType_PingSetting PingSetting;
  static constexpr PingSetting SAMPLED_PING =
    DownloadFileType_PingSetting_SAMPLED_PING;
  static constexpr PingSetting NO_PING =
    DownloadFileType_PingSetting_NO_PING;
  static constexpr PingSetting FULL_PING =
    DownloadFileType_PingSetting_FULL_PING;
  static inline bool PingSetting_IsValid(int value) {
    return DownloadFileType_PingSetting_IsValid(value);
  }
  static constexpr PingSetting PingSetting_MIN =
    DownloadFileType_PingSetting_PingSetting_MIN;
  static constexpr PingSetting PingSetting_MAX =
    DownloadFileType_PingSetting_PingSetting_MAX;
  static constexpr int PingSetting_ARRAYSIZE =
    DownloadFileType_PingSetting_PingSetting_ARRAYSIZE;
  template<typename T>
  static inline const std::string& PingSetting_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PingSetting>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PingSetting_Name.");
    return DownloadFileType_PingSetting_Name(enum_t_value);
  }
  static inline bool PingSetting_Parse(const std::string& name,
      PingSetting* value) {
    return DownloadFileType_PingSetting_Parse(name, value);
  }

  typedef DownloadFileType_DangerLevel DangerLevel;
  static constexpr DangerLevel NOT_DANGEROUS =
    DownloadFileType_DangerLevel_NOT_DANGEROUS;
  static constexpr DangerLevel ALLOW_ON_USER_GESTURE =
    DownloadFileType_DangerLevel_ALLOW_ON_USER_GESTURE;
  static constexpr DangerLevel DANGEROUS =
    DownloadFileType_DangerLevel_DANGEROUS;
  static inline bool DangerLevel_IsValid(int value) {
    return DownloadFileType_DangerLevel_IsValid(value);
  }
  static constexpr DangerLevel DangerLevel_MIN =
    DownloadFileType_DangerLevel_DangerLevel_MIN;
  static constexpr DangerLevel DangerLevel_MAX =
    DownloadFileType_DangerLevel_DangerLevel_MAX;
  static constexpr int DangerLevel_ARRAYSIZE =
    DownloadFileType_DangerLevel_DangerLevel_ARRAYSIZE;
  template<typename T>
  static inline const std::string& DangerLevel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DangerLevel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DangerLevel_Name.");
    return DownloadFileType_DangerLevel_Name(enum_t_value);
  }
  static inline bool DangerLevel_Parse(const std::string& name,
      DangerLevel* value) {
    return DownloadFileType_DangerLevel_Parse(name, value);
  }

  typedef DownloadFileType_AutoOpenHint AutoOpenHint;
  static constexpr AutoOpenHint DISALLOW_AUTO_OPEN =
    DownloadFileType_AutoOpenHint_DISALLOW_AUTO_OPEN;
  static constexpr AutoOpenHint ALLOW_AUTO_OPEN =
    DownloadFileType_AutoOpenHint_ALLOW_AUTO_OPEN;
  static inline bool AutoOpenHint_IsValid(int value) {
    return DownloadFileType_AutoOpenHint_IsValid(value);
  }
  static constexpr AutoOpenHint AutoOpenHint_MIN =
    DownloadFileType_AutoOpenHint_AutoOpenHint_MIN;
  static constexpr AutoOpenHint AutoOpenHint_MAX =
    DownloadFileType_AutoOpenHint_AutoOpenHint_MAX;
  static constexpr int AutoOpenHint_ARRAYSIZE =
    DownloadFileType_AutoOpenHint_AutoOpenHint_ARRAYSIZE;
  template<typename T>
  static inline const std::string& AutoOpenHint_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AutoOpenHint>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AutoOpenHint_Name.");
    return DownloadFileType_AutoOpenHint_Name(enum_t_value);
  }
  static inline bool AutoOpenHint_Parse(const std::string& name,
      AutoOpenHint* value) {
    return DownloadFileType_AutoOpenHint_Parse(name, value);
  }

  typedef DownloadFileType_PlatformType PlatformType;
  static constexpr PlatformType PLATFORM_ANY =
    DownloadFileType_PlatformType_PLATFORM_ANY;
  static constexpr PlatformType PLATFORM_ANDROID =
    DownloadFileType_PlatformType_PLATFORM_ANDROID;
  static constexpr PlatformType PLATFORM_CHROME_OS =
    DownloadFileType_PlatformType_PLATFORM_CHROME_OS;
  static constexpr PlatformType PLATFORM_LINUX =
    DownloadFileType_PlatformType_PLATFORM_LINUX;
  static constexpr PlatformType PLATFORM_MAC =
    DownloadFileType_PlatformType_PLATFORM_MAC;
  static constexpr PlatformType PLATFORM_WINDOWS =
    DownloadFileType_PlatformType_PLATFORM_WINDOWS;
  static inline bool PlatformType_IsValid(int value) {
    return DownloadFileType_PlatformType_IsValid(value);
  }
  static constexpr PlatformType PlatformType_MIN =
    DownloadFileType_PlatformType_PlatformType_MIN;
  static constexpr PlatformType PlatformType_MAX =
    DownloadFileType_PlatformType_PlatformType_MAX;
  static constexpr int PlatformType_ARRAYSIZE =
    DownloadFileType_PlatformType_PlatformType_ARRAYSIZE;
  template<typename T>
  static 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 DownloadFileType_PlatformType_Name(enum_t_value);
  }
  static inline bool PlatformType_Parse(const std::string& name,
      PlatformType* value) {
    return DownloadFileType_PlatformType_Parse(name, value);
  }

  typedef DownloadFileType_InspectionType InspectionType;
  static constexpr InspectionType NONE =
    DownloadFileType_InspectionType_NONE;
  static constexpr InspectionType ZIP =
    DownloadFileType_InspectionType_ZIP;
  static constexpr InspectionType RAR =
    DownloadFileType_InspectionType_RAR;
  static constexpr InspectionType DMG =
    DownloadFileType_InspectionType_DMG;
  static inline bool InspectionType_IsValid(int value) {
    return DownloadFileType_InspectionType_IsValid(value);
  }
  static constexpr InspectionType InspectionType_MIN =
    DownloadFileType_InspectionType_InspectionType_MIN;
  static constexpr InspectionType InspectionType_MAX =
    DownloadFileType_InspectionType_InspectionType_MAX;
  static constexpr int InspectionType_ARRAYSIZE =
    DownloadFileType_InspectionType_InspectionType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& InspectionType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, InspectionType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function InspectionType_Name.");
    return DownloadFileType_InspectionType_Name(enum_t_value);
  }
  static inline bool InspectionType_Parse(const std::string& name,
      InspectionType* value) {
    return DownloadFileType_InspectionType_Parse(name, value);
  }

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

  enum : int {
    kPlatformSettingsFieldNumber = 5,
    kExtensionFieldNumber = 1,
    kUmaValueFieldNumber = 2,
    kIsArchiveFieldNumber = 3,
    kPingSettingFieldNumber = 4,
    kInspectionTypeFieldNumber = 6,
  };
  // repeated .safe_browsing.DownloadFileType.PlatformSettings platform_settings = 5;
  int platform_settings_size() const;
  void clear_platform_settings();
  ::safe_browsing::DownloadFileType_PlatformSettings* mutable_platform_settings(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType_PlatformSettings >*
      mutable_platform_settings();
  const ::safe_browsing::DownloadFileType_PlatformSettings& platform_settings(int index) const;
  ::safe_browsing::DownloadFileType_PlatformSettings* add_platform_settings();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType_PlatformSettings >&
      platform_settings() const;

  // optional string extension = 1;
  bool has_extension() const;
  void clear_extension();
  const std::string& extension() const;
  void set_extension(const std::string& value);
  void set_extension(std::string&& value);
  void set_extension(const char* value);
  void set_extension(const char* value, size_t size);
  std::string* mutable_extension();
  std::string* release_extension();
  void set_allocated_extension(std::string* extension);

  // optional int64 uma_value = 2;
  bool has_uma_value() const;
  void clear_uma_value();
  ::PROTOBUF_NAMESPACE_ID::int64 uma_value() const;
  void set_uma_value(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional bool is_archive = 3 [default = false];
  bool has_is_archive() const;
  void clear_is_archive();
  bool is_archive() const;
  void set_is_archive(bool value);

  // optional .safe_browsing.DownloadFileType.PingSetting ping_setting = 4;
  bool has_ping_setting() const;
  void clear_ping_setting();
  ::safe_browsing::DownloadFileType_PingSetting ping_setting() const;
  void set_ping_setting(::safe_browsing::DownloadFileType_PingSetting value);

  // optional .safe_browsing.DownloadFileType.InspectionType inspection_type = 6;
  bool has_inspection_type() const;
  void clear_inspection_type();
  ::safe_browsing::DownloadFileType_InspectionType inspection_type() const;
  void set_inspection_type(::safe_browsing::DownloadFileType_InspectionType value);

  // @@protoc_insertion_point(class_scope:safe_browsing.DownloadFileType)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType_PlatformSettings > platform_settings_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extension_;
  ::PROTOBUF_NAMESPACE_ID::int64 uma_value_;
  bool is_archive_;
  int ping_setting_;
  int inspection_type_;
  friend struct ::TableStruct_download_5ffile_5ftypes_2eproto;
};
// -------------------------------------------------------------------

class DownloadFileTypeConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DownloadFileTypeConfig) */ {
 public:
  DownloadFileTypeConfig();
  virtual ~DownloadFileTypeConfig();

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

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

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const DownloadFileTypeConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DownloadFileTypeConfig* internal_default_instance() {
    return reinterpret_cast<const DownloadFileTypeConfig*>(
               &_DownloadFileTypeConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(DownloadFileTypeConfig& a, DownloadFileTypeConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(DownloadFileTypeConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline DownloadFileTypeConfig* New() const final {
    return CreateMaybeMessage<DownloadFileTypeConfig>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DownloadFileTypeConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "safe_browsing.DownloadFileTypeConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kFileTypesFieldNumber = 3,
    kDefaultFileTypeFieldNumber = 4,
    kVersionIdFieldNumber = 1,
    kSampledPingProbabilityFieldNumber = 2,
    kMaxArchivedBinariesToReportFieldNumber = 5,
  };
  // repeated .safe_browsing.DownloadFileType file_types = 3;
  int file_types_size() const;
  void clear_file_types();
  ::safe_browsing::DownloadFileType* mutable_file_types(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType >*
      mutable_file_types();
  const ::safe_browsing::DownloadFileType& file_types(int index) const;
  ::safe_browsing::DownloadFileType* add_file_types();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType >&
      file_types() const;

  // optional .safe_browsing.DownloadFileType default_file_type = 4;
  bool has_default_file_type() const;
  void clear_default_file_type();
  const ::safe_browsing::DownloadFileType& default_file_type() const;
  ::safe_browsing::DownloadFileType* release_default_file_type();
  ::safe_browsing::DownloadFileType* mutable_default_file_type();
  void set_allocated_default_file_type(::safe_browsing::DownloadFileType* default_file_type);

  // optional uint32 version_id = 1;
  bool has_version_id() const;
  void clear_version_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 version_id() const;
  void set_version_id(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional float sampled_ping_probability = 2;
  bool has_sampled_ping_probability() const;
  void clear_sampled_ping_probability();
  float sampled_ping_probability() const;
  void set_sampled_ping_probability(float value);

  // optional uint64 max_archived_binaries_to_report = 5;
  bool has_max_archived_binaries_to_report() const;
  void clear_max_archived_binaries_to_report();
  ::PROTOBUF_NAMESPACE_ID::uint64 max_archived_binaries_to_report() const;
  void set_max_archived_binaries_to_report(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:safe_browsing.DownloadFileTypeConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType > file_types_;
  ::safe_browsing::DownloadFileType* default_file_type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 version_id_;
  float sampled_ping_probability_;
  ::PROTOBUF_NAMESPACE_ID::uint64 max_archived_binaries_to_report_;
  friend struct ::TableStruct_download_5ffile_5ftypes_2eproto;
};
// ===================================================================


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

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

// optional .safe_browsing.DownloadFileType.PlatformType platform = 1 [default = PLATFORM_ANY];
inline bool DownloadFileType_PlatformSettings::has_platform() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DownloadFileType_PlatformSettings::clear_platform() {
  platform_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::safe_browsing::DownloadFileType_PlatformType DownloadFileType_PlatformSettings::platform() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.PlatformSettings.platform)
  return static_cast< ::safe_browsing::DownloadFileType_PlatformType >(platform_);
}
inline void DownloadFileType_PlatformSettings::set_platform(::safe_browsing::DownloadFileType_PlatformType value) {
  assert(::safe_browsing::DownloadFileType_PlatformType_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  platform_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.PlatformSettings.platform)
}

// optional .safe_browsing.DownloadFileType.DangerLevel danger_level = 2;
inline bool DownloadFileType_PlatformSettings::has_danger_level() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DownloadFileType_PlatformSettings::clear_danger_level() {
  danger_level_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::safe_browsing::DownloadFileType_DangerLevel DownloadFileType_PlatformSettings::danger_level() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.PlatformSettings.danger_level)
  return static_cast< ::safe_browsing::DownloadFileType_DangerLevel >(danger_level_);
}
inline void DownloadFileType_PlatformSettings::set_danger_level(::safe_browsing::DownloadFileType_DangerLevel value) {
  assert(::safe_browsing::DownloadFileType_DangerLevel_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  danger_level_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.PlatformSettings.danger_level)
}

// optional .safe_browsing.DownloadFileType.AutoOpenHint auto_open_hint = 3;
inline bool DownloadFileType_PlatformSettings::has_auto_open_hint() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DownloadFileType_PlatformSettings::clear_auto_open_hint() {
  auto_open_hint_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::safe_browsing::DownloadFileType_AutoOpenHint DownloadFileType_PlatformSettings::auto_open_hint() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.PlatformSettings.auto_open_hint)
  return static_cast< ::safe_browsing::DownloadFileType_AutoOpenHint >(auto_open_hint_);
}
inline void DownloadFileType_PlatformSettings::set_auto_open_hint(::safe_browsing::DownloadFileType_AutoOpenHint value) {
  assert(::safe_browsing::DownloadFileType_AutoOpenHint_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  auto_open_hint_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.PlatformSettings.auto_open_hint)
}

// optional uint64 max_file_size_to_analyze = 4 [default = 18446744073709551615];
inline bool DownloadFileType_PlatformSettings::has_max_file_size_to_analyze() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DownloadFileType_PlatformSettings::clear_max_file_size_to_analyze() {
  max_file_size_to_analyze_ = PROTOBUF_ULONGLONG(18446744073709551615);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 DownloadFileType_PlatformSettings::max_file_size_to_analyze() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.PlatformSettings.max_file_size_to_analyze)
  return max_file_size_to_analyze_;
}
inline void DownloadFileType_PlatformSettings::set_max_file_size_to_analyze(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  max_file_size_to_analyze_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.PlatformSettings.max_file_size_to_analyze)
}

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

// DownloadFileType

// optional string extension = 1;
inline bool DownloadFileType::has_extension() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DownloadFileType::clear_extension() {
  extension_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DownloadFileType::extension() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.extension)
  return extension_.GetNoArena();
}
inline void DownloadFileType::set_extension(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  extension_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.extension)
}
inline void DownloadFileType::set_extension(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  extension_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:safe_browsing.DownloadFileType.extension)
}
inline void DownloadFileType::set_extension(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  extension_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:safe_browsing.DownloadFileType.extension)
}
inline void DownloadFileType::set_extension(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  extension_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:safe_browsing.DownloadFileType.extension)
}
inline std::string* DownloadFileType::mutable_extension() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadFileType.extension)
  return extension_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DownloadFileType::release_extension() {
  // @@protoc_insertion_point(field_release:safe_browsing.DownloadFileType.extension)
  if (!has_extension()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return extension_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DownloadFileType::set_allocated_extension(std::string* extension) {
  if (extension != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  extension_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extension);
  // @@protoc_insertion_point(field_set_allocated:safe_browsing.DownloadFileType.extension)
}

// optional int64 uma_value = 2;
inline bool DownloadFileType::has_uma_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DownloadFileType::clear_uma_value() {
  uma_value_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DownloadFileType::uma_value() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.uma_value)
  return uma_value_;
}
inline void DownloadFileType::set_uma_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  uma_value_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.uma_value)
}

// optional bool is_archive = 3 [default = false];
inline bool DownloadFileType::has_is_archive() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DownloadFileType::clear_is_archive() {
  is_archive_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool DownloadFileType::is_archive() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.is_archive)
  return is_archive_;
}
inline void DownloadFileType::set_is_archive(bool value) {
  _has_bits_[0] |= 0x00000004u;
  is_archive_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.is_archive)
}

// optional .safe_browsing.DownloadFileType.PingSetting ping_setting = 4;
inline bool DownloadFileType::has_ping_setting() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DownloadFileType::clear_ping_setting() {
  ping_setting_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::safe_browsing::DownloadFileType_PingSetting DownloadFileType::ping_setting() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.ping_setting)
  return static_cast< ::safe_browsing::DownloadFileType_PingSetting >(ping_setting_);
}
inline void DownloadFileType::set_ping_setting(::safe_browsing::DownloadFileType_PingSetting value) {
  assert(::safe_browsing::DownloadFileType_PingSetting_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  ping_setting_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.ping_setting)
}

// repeated .safe_browsing.DownloadFileType.PlatformSettings platform_settings = 5;
inline int DownloadFileType::platform_settings_size() const {
  return platform_settings_.size();
}
inline void DownloadFileType::clear_platform_settings() {
  platform_settings_.Clear();
}
inline ::safe_browsing::DownloadFileType_PlatformSettings* DownloadFileType::mutable_platform_settings(int index) {
  // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadFileType.platform_settings)
  return platform_settings_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType_PlatformSettings >*
DownloadFileType::mutable_platform_settings() {
  // @@protoc_insertion_point(field_mutable_list:safe_browsing.DownloadFileType.platform_settings)
  return &platform_settings_;
}
inline const ::safe_browsing::DownloadFileType_PlatformSettings& DownloadFileType::platform_settings(int index) const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.platform_settings)
  return platform_settings_.Get(index);
}
inline ::safe_browsing::DownloadFileType_PlatformSettings* DownloadFileType::add_platform_settings() {
  // @@protoc_insertion_point(field_add:safe_browsing.DownloadFileType.platform_settings)
  return platform_settings_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType_PlatformSettings >&
DownloadFileType::platform_settings() const {
  // @@protoc_insertion_point(field_list:safe_browsing.DownloadFileType.platform_settings)
  return platform_settings_;
}

// optional .safe_browsing.DownloadFileType.InspectionType inspection_type = 6;
inline bool DownloadFileType::has_inspection_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DownloadFileType::clear_inspection_type() {
  inspection_type_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::safe_browsing::DownloadFileType_InspectionType DownloadFileType::inspection_type() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileType.inspection_type)
  return static_cast< ::safe_browsing::DownloadFileType_InspectionType >(inspection_type_);
}
inline void DownloadFileType::set_inspection_type(::safe_browsing::DownloadFileType_InspectionType value) {
  assert(::safe_browsing::DownloadFileType_InspectionType_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  inspection_type_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileType.inspection_type)
}

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

// DownloadFileTypeConfig

// optional uint32 version_id = 1;
inline bool DownloadFileTypeConfig::has_version_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DownloadFileTypeConfig::clear_version_id() {
  version_id_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DownloadFileTypeConfig::version_id() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileTypeConfig.version_id)
  return version_id_;
}
inline void DownloadFileTypeConfig::set_version_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  version_id_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileTypeConfig.version_id)
}

// optional float sampled_ping_probability = 2;
inline bool DownloadFileTypeConfig::has_sampled_ping_probability() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DownloadFileTypeConfig::clear_sampled_ping_probability() {
  sampled_ping_probability_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float DownloadFileTypeConfig::sampled_ping_probability() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileTypeConfig.sampled_ping_probability)
  return sampled_ping_probability_;
}
inline void DownloadFileTypeConfig::set_sampled_ping_probability(float value) {
  _has_bits_[0] |= 0x00000004u;
  sampled_ping_probability_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileTypeConfig.sampled_ping_probability)
}

// repeated .safe_browsing.DownloadFileType file_types = 3;
inline int DownloadFileTypeConfig::file_types_size() const {
  return file_types_.size();
}
inline void DownloadFileTypeConfig::clear_file_types() {
  file_types_.Clear();
}
inline ::safe_browsing::DownloadFileType* DownloadFileTypeConfig::mutable_file_types(int index) {
  // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadFileTypeConfig.file_types)
  return file_types_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType >*
DownloadFileTypeConfig::mutable_file_types() {
  // @@protoc_insertion_point(field_mutable_list:safe_browsing.DownloadFileTypeConfig.file_types)
  return &file_types_;
}
inline const ::safe_browsing::DownloadFileType& DownloadFileTypeConfig::file_types(int index) const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileTypeConfig.file_types)
  return file_types_.Get(index);
}
inline ::safe_browsing::DownloadFileType* DownloadFileTypeConfig::add_file_types() {
  // @@protoc_insertion_point(field_add:safe_browsing.DownloadFileTypeConfig.file_types)
  return file_types_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::DownloadFileType >&
DownloadFileTypeConfig::file_types() const {
  // @@protoc_insertion_point(field_list:safe_browsing.DownloadFileTypeConfig.file_types)
  return file_types_;
}

// optional .safe_browsing.DownloadFileType default_file_type = 4;
inline bool DownloadFileTypeConfig::has_default_file_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DownloadFileTypeConfig::clear_default_file_type() {
  if (default_file_type_ != nullptr) default_file_type_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::safe_browsing::DownloadFileType& DownloadFileTypeConfig::default_file_type() const {
  const ::safe_browsing::DownloadFileType* p = default_file_type_;
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileTypeConfig.default_file_type)
  return p != nullptr ? *p : *reinterpret_cast<const ::safe_browsing::DownloadFileType*>(
      &::safe_browsing::_DownloadFileType_default_instance_);
}
inline ::safe_browsing::DownloadFileType* DownloadFileTypeConfig::release_default_file_type() {
  // @@protoc_insertion_point(field_release:safe_browsing.DownloadFileTypeConfig.default_file_type)
  _has_bits_[0] &= ~0x00000001u;
  ::safe_browsing::DownloadFileType* temp = default_file_type_;
  default_file_type_ = nullptr;
  return temp;
}
inline ::safe_browsing::DownloadFileType* DownloadFileTypeConfig::mutable_default_file_type() {
  _has_bits_[0] |= 0x00000001u;
  if (default_file_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::safe_browsing::DownloadFileType>(GetArenaNoVirtual());
    default_file_type_ = p;
  }
  // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadFileTypeConfig.default_file_type)
  return default_file_type_;
}
inline void DownloadFileTypeConfig::set_allocated_default_file_type(::safe_browsing::DownloadFileType* default_file_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete default_file_type_;
  }
  if (default_file_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      default_file_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, default_file_type, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  default_file_type_ = default_file_type;
  // @@protoc_insertion_point(field_set_allocated:safe_browsing.DownloadFileTypeConfig.default_file_type)
}

// optional uint64 max_archived_binaries_to_report = 5;
inline bool DownloadFileTypeConfig::has_max_archived_binaries_to_report() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DownloadFileTypeConfig::clear_max_archived_binaries_to_report() {
  max_archived_binaries_to_report_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 DownloadFileTypeConfig::max_archived_binaries_to_report() const {
  // @@protoc_insertion_point(field_get:safe_browsing.DownloadFileTypeConfig.max_archived_binaries_to_report)
  return max_archived_binaries_to_report_;
}
inline void DownloadFileTypeConfig::set_max_archived_binaries_to_report(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000008u;
  max_archived_binaries_to_report_ = value;
  // @@protoc_insertion_point(field_set:safe_browsing.DownloadFileTypeConfig.max_archived_binaries_to_report)
}

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace safe_browsing

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::safe_browsing::DownloadFileType_PingSetting> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DownloadFileType_DangerLevel> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DownloadFileType_AutoOpenHint> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DownloadFileType_PlatformType> : ::std::true_type {};
template <> struct is_proto_enum< ::safe_browsing::DownloadFileType_InspectionType> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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