// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: lib/config/config.proto
// Protobuf C++ Version: 7.36.0

#ifndef lib_2fconfig_2fconfig_2eproto_2epb_2eh
#define lib_2fconfig_2fconfig_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7036000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/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_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "lib/decoders/decoders.pb.h"
#include "lib/encoders/encoders.pb.h"
#include "lib/imagereader/imagereader.pb.h"
#include "lib/imagewriter/imagewriter.pb.h"
#include "lib/fluxsource/fluxsource.pb.h"
#include "lib/fluxsink/fluxsink.pb.h"
#include "lib/usb/usb.pb.h"
#include "lib/vfs/vfs.pb.h"
#include "lib/config/drive.pb.h"
#include "lib/config/common.pb.h"
#include "lib/config/layout.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_lib_2fconfig_2fconfig_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2fconfig_2fconfig_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2fconfig_2fconfig_2eproto;
}  // extern "C"
enum OptionApplicabilityHint : int;
extern const uint32_t OptionApplicabilityHint_internal_data_[];
enum SupportStatus : int;
extern const uint32_t SupportStatus_internal_data_[];
class ConfigProto;
struct ConfigProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ConfigProtoGlobalsTypeInternal ConfigProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ConfigProto_class_data_;
#else
extern const ConfigProtoGlobalsTypeInternal ConfigProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class OptionGroupProto;
struct OptionGroupProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern OptionGroupProtoGlobalsTypeInternal OptionGroupProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull OptionGroupProto_class_data_;
#else
extern const OptionGroupProtoGlobalsTypeInternal OptionGroupProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class OptionPrerequisiteProto;
struct OptionPrerequisiteProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern OptionPrerequisiteProtoGlobalsTypeInternal OptionPrerequisiteProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull OptionPrerequisiteProto_class_data_;
#else
extern const OptionPrerequisiteProtoGlobalsTypeInternal OptionPrerequisiteProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class OptionProto;
struct OptionProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern OptionProtoGlobalsTypeInternal OptionProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull OptionProto_class_data_;
#else
extern const OptionProtoGlobalsTypeInternal OptionProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::OptionApplicabilityHint_internal_data_>
    internal::EnumTraitsImpl::value<::OptionApplicabilityHint>;
template <>
internal::EnumTraitsT<::SupportStatus_internal_data_>
    internal::EnumTraitsImpl::value<::SupportStatus>;
}  // namespace protobuf
}  // namespace google

enum SupportStatus : int {
  UNSUPPORTED = 0,
  DINOSAUR = 1,
  UNICORN = 2,
};

extern const uint32_t SupportStatus_internal_data_[];
inline constexpr SupportStatus SupportStatus_MIN =
    static_cast<SupportStatus>(0);
inline constexpr SupportStatus SupportStatus_MAX =
    static_cast<SupportStatus>(2);
[[nodiscard]] inline bool SupportStatus_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int SupportStatus_ARRAYSIZE = 2 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
SupportStatus_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(SupportStatus) {
  return SupportStatus_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& SupportStatus_Name(T value) {
  static_assert(::std::is_same<T, SupportStatus>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to SupportStatus_Name().");
  return SupportStatus_Name(static_cast<SupportStatus>(value));
}
template <>
[[nodiscard]] inline const ::std::string& SupportStatus_Name(SupportStatus value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SupportStatus_descriptor, 0, 2>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool SupportStatus_Parse(
    ::absl::string_view name, SupportStatus* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SupportStatus>(SupportStatus_descriptor(), name,
                                           value);
}
enum OptionApplicabilityHint : int {
  FORMAT = 0,
  ANY_SOURCESINK = 1,
  HARDWARE_SOURCESINK = 2,
  MANUAL_SOURCESINK = 3,
  FLUXFILE_SOURCESINK = 4,
};

extern const uint32_t OptionApplicabilityHint_internal_data_[];
inline constexpr OptionApplicabilityHint OptionApplicabilityHint_MIN =
    static_cast<OptionApplicabilityHint>(0);
inline constexpr OptionApplicabilityHint OptionApplicabilityHint_MAX =
    static_cast<OptionApplicabilityHint>(4);
[[nodiscard]] inline bool OptionApplicabilityHint_IsValid(int value) {
  return 0 <= value && value <= 4;
}
inline constexpr int OptionApplicabilityHint_ARRAYSIZE = 4 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
OptionApplicabilityHint_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(OptionApplicabilityHint) {
  return OptionApplicabilityHint_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& OptionApplicabilityHint_Name(T value) {
  static_assert(::std::is_same<T, OptionApplicabilityHint>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to OptionApplicabilityHint_Name().");
  return OptionApplicabilityHint_Name(static_cast<OptionApplicabilityHint>(value));
}
template <>
[[nodiscard]] inline const ::std::string& OptionApplicabilityHint_Name(OptionApplicabilityHint value) {
  return ::google::protobuf::internal::NameOfDenseEnum<OptionApplicabilityHint_descriptor, 0, 4>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool OptionApplicabilityHint_Parse(
    ::absl::string_view name, OptionApplicabilityHint* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<OptionApplicabilityHint>(OptionApplicabilityHint_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED OptionPrerequisiteProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:OptionPrerequisiteProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline OptionPrerequisiteProto() : OptionPrerequisiteProto(nullptr) {}
  ~OptionPrerequisiteProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(OptionPrerequisiteProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(OptionPrerequisiteProto));
  }
#endif

  template <typename = void>
  explicit constexpr OptionPrerequisiteProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline OptionPrerequisiteProto(const OptionPrerequisiteProto& from) : OptionPrerequisiteProto(nullptr, from) {}
  inline OptionPrerequisiteProto(OptionPrerequisiteProto&& from) noexcept : OptionPrerequisiteProto(nullptr, ::std::move(from)) {}
  inline OptionPrerequisiteProto& operator=(const OptionPrerequisiteProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline OptionPrerequisiteProto& operator=(OptionPrerequisiteProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const OptionPrerequisiteProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<OptionPrerequisiteProto>(&OptionPrerequisiteProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(OptionPrerequisiteProto& a, OptionPrerequisiteProto& b) { a.Swap(&b); }
  inline void Swap(OptionPrerequisiteProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OptionPrerequisiteProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] OptionPrerequisiteProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<OptionPrerequisiteProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const OptionPrerequisiteProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const OptionPrerequisiteProto& from) { OptionPrerequisiteProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(OptionPrerequisiteProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "OptionPrerequisiteProto"; }

  explicit OptionPrerequisiteProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  OptionPrerequisiteProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionPrerequisiteProto& from);
  OptionPrerequisiteProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OptionPrerequisiteProto&& from) noexcept
      : OptionPrerequisiteProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kValueFieldNumber = 2,
    kKeyFieldNumber = 1,
  };
  // repeated string value = 2 [json_name = "value", (.help) = "list of required values"];
  [[nodiscard]] int value_size() const;
  private:
  int _internal_value_size() const;

  public:
  void clear_value() ;
  [[nodiscard]] const ::std::string& value(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_value(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_value(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_value();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_value(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      value() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_value();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_value() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_value();

  public:
  // optional string key = 1 [json_name = "key", (.help) = "path to config value"];
  [[nodiscard]] bool has_key() const;
  void clear_key() ;
  [[nodiscard]] const ::std::string& key() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_key();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key();
  void set_allocated_key(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_key() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_key();

  public:
  // @@protoc_insertion_point(class_scope:OptionPrerequisiteProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const OptionPrerequisiteProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> value_;
    ::google::protobuf::internal::ArenaStringPtr key_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fconfig_2fconfig_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ConfigProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:ConfigProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline ConfigProto() : ConfigProto(nullptr) {}
  ~ConfigProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ConfigProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ConfigProto));
  }
#endif

  template <typename = void>
  explicit constexpr ConfigProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ConfigProto(const ConfigProto& from) : ConfigProto(nullptr, from) {}
  inline ConfigProto(ConfigProto&& from) noexcept : ConfigProto(nullptr, ::std::move(from)) {}
  inline ConfigProto& operator=(const ConfigProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConfigProto& operator=(ConfigProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ConfigProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ConfigProto>(&ConfigProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(ConfigProto& a, ConfigProto& b) { a.Swap(&b); }
  inline void Swap(ConfigProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConfigProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ConfigProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ConfigProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ConfigProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ConfigProto& from) { ConfigProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ConfigProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ConfigProto"; }

  explicit ConfigProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ConfigProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConfigProto& from);
  ConfigProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConfigProto&& from) noexcept
      : ConfigProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDocumentationFieldNumber = 4,
    kOptionFieldNumber = 19,
    kOptionGroupFieldNumber = 20,
    kShortnameFieldNumber = 1,
    kCommentFieldNumber = 2,
    kTracksFieldNumber = 16,
    kLayoutFieldNumber = 7,
    kImageReaderFieldNumber = 8,
    kImageWriterFieldNumber = 9,
    kFluxSourceFieldNumber = 10,
    kFluxSinkFieldNumber = 11,
    kDriveFieldNumber = 12,
    kEncoderFieldNumber = 13,
    kDecoderFieldNumber = 14,
    kUsbFieldNumber = 15,
    kFilesystemFieldNumber = 18,
    kIsExtensionFieldNumber = 3,
    kReadSupportStatusFieldNumber = 5,
    kWriteSupportStatusFieldNumber = 6,
  };
  // repeated string documentation = 4 [json_name = "documentation"];
  [[nodiscard]] int documentation_size() const;
  private:
  int _internal_documentation_size() const;

  public:
  void clear_documentation() ;
  [[nodiscard]] const ::std::string& documentation(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_documentation(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_documentation(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_documentation();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_documentation(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      documentation() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_documentation();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_documentation() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_documentation();

  public:
  // repeated .OptionProto option = 19 [json_name = "option"];
  [[nodiscard]] int option_size() const;
  private:
  int _internal_option_size() const;

  public:
  void clear_option() ;
  [[nodiscard]] const ::OptionProto& option(int index) const;
  [[nodiscard]] ::OptionProto* PROTOBUF_NONNULL mutable_option(int index);
  ::OptionProto* PROTOBUF_NONNULL add_option();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::OptionProto>&
  option() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL
  mutable_option();

  private:
  const ::google::protobuf::RepeatedPtrField<::OptionProto>& _internal_option() const;
  ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL _internal_mutable_option();

  public:
  // repeated .OptionGroupProto option_group = 20 [json_name = "optionGroup"];
  [[nodiscard]] int option_group_size() const;
  private:
  int _internal_option_group_size() const;

  public:
  void clear_option_group() ;
  [[nodiscard]] const ::OptionGroupProto& option_group(int index) const;
  [[nodiscard]] ::OptionGroupProto* PROTOBUF_NONNULL mutable_option_group(int index);
  ::OptionGroupProto* PROTOBUF_NONNULL add_option_group();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::OptionGroupProto>&
  option_group() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::OptionGroupProto>* PROTOBUF_NONNULL
  mutable_option_group();

  private:
  const ::google::protobuf::RepeatedPtrField<::OptionGroupProto>& _internal_option_group() const;
  ::google::protobuf::RepeatedPtrField<::OptionGroupProto>* PROTOBUF_NONNULL _internal_mutable_option_group();

  public:
  // optional string shortname = 1 [json_name = "shortname"];
  [[nodiscard]] bool has_shortname() const;
  void clear_shortname() ;
  [[nodiscard]] const ::std::string& shortname() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_shortname(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_shortname();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_shortname();
  void set_allocated_shortname(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_shortname() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_shortname(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_shortname();

  public:
  // optional string comment = 2 [json_name = "comment"];
  [[nodiscard]] bool has_comment() const;
  void clear_comment() ;
  [[nodiscard]] const ::std::string& comment() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_comment(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_comment();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_comment();
  void set_allocated_comment(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_comment() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_comment();

  public:
  // optional string tracks = 16 [json_name = "tracks"];
  [[nodiscard]] bool has_tracks() const;
  void clear_tracks() ;
  [[nodiscard]] const ::std::string& tracks() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_tracks(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_tracks();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_tracks();
  void set_allocated_tracks(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_tracks() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_tracks(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_tracks();

  public:
  // optional .LayoutProto layout = 7 [json_name = "layout"];
  [[nodiscard]] bool has_layout() const;
  void clear_layout() ;
  [[nodiscard]] const ::LayoutProto& layout() const;
  [[nodiscard]] ::LayoutProto* PROTOBUF_NULLABLE release_layout();
  ::LayoutProto* PROTOBUF_NONNULL mutable_layout();
  void set_allocated_layout(::LayoutProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_layout(::LayoutProto* PROTOBUF_NULLABLE value);
  ::LayoutProto* PROTOBUF_NULLABLE unsafe_arena_release_layout();

  private:
  const ::LayoutProto& _internal_layout() const;
  ::LayoutProto* PROTOBUF_NONNULL _internal_mutable_layout();

  public:
  // optional .ImageReaderProto image_reader = 8 [json_name = "imageReader"];
  [[nodiscard]] bool has_image_reader() const;
  void clear_image_reader() ;
  [[nodiscard]] const ::ImageReaderProto& image_reader() const;
  [[nodiscard]] ::ImageReaderProto* PROTOBUF_NULLABLE release_image_reader();
  ::ImageReaderProto* PROTOBUF_NONNULL mutable_image_reader();
  void set_allocated_image_reader(::ImageReaderProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_image_reader(::ImageReaderProto* PROTOBUF_NULLABLE value);
  ::ImageReaderProto* PROTOBUF_NULLABLE unsafe_arena_release_image_reader();

  private:
  const ::ImageReaderProto& _internal_image_reader() const;
  ::ImageReaderProto* PROTOBUF_NONNULL _internal_mutable_image_reader();

  public:
  // optional .ImageWriterProto image_writer = 9 [json_name = "imageWriter"];
  [[nodiscard]] bool has_image_writer() const;
  void clear_image_writer() ;
  [[nodiscard]] const ::ImageWriterProto& image_writer() const;
  [[nodiscard]] ::ImageWriterProto* PROTOBUF_NULLABLE release_image_writer();
  ::ImageWriterProto* PROTOBUF_NONNULL mutable_image_writer();
  void set_allocated_image_writer(::ImageWriterProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_image_writer(::ImageWriterProto* PROTOBUF_NULLABLE value);
  ::ImageWriterProto* PROTOBUF_NULLABLE unsafe_arena_release_image_writer();

  private:
  const ::ImageWriterProto& _internal_image_writer() const;
  ::ImageWriterProto* PROTOBUF_NONNULL _internal_mutable_image_writer();

  public:
  // optional .FluxSourceProto flux_source = 10 [json_name = "fluxSource"];
  [[nodiscard]] bool has_flux_source() const;
  void clear_flux_source() ;
  [[nodiscard]] const ::FluxSourceProto& flux_source() const;
  [[nodiscard]] ::FluxSourceProto* PROTOBUF_NULLABLE release_flux_source();
  ::FluxSourceProto* PROTOBUF_NONNULL mutable_flux_source();
  void set_allocated_flux_source(::FluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_flux_source(::FluxSourceProto* PROTOBUF_NULLABLE value);
  ::FluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_flux_source();

  private:
  const ::FluxSourceProto& _internal_flux_source() const;
  ::FluxSourceProto* PROTOBUF_NONNULL _internal_mutable_flux_source();

  public:
  // optional .FluxSinkProto flux_sink = 11 [json_name = "fluxSink"];
  [[nodiscard]] bool has_flux_sink() const;
  void clear_flux_sink() ;
  [[nodiscard]] const ::FluxSinkProto& flux_sink() const;
  [[nodiscard]] ::FluxSinkProto* PROTOBUF_NULLABLE release_flux_sink();
  ::FluxSinkProto* PROTOBUF_NONNULL mutable_flux_sink();
  void set_allocated_flux_sink(::FluxSinkProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_flux_sink(::FluxSinkProto* PROTOBUF_NULLABLE value);
  ::FluxSinkProto* PROTOBUF_NULLABLE unsafe_arena_release_flux_sink();

  private:
  const ::FluxSinkProto& _internal_flux_sink() const;
  ::FluxSinkProto* PROTOBUF_NONNULL _internal_mutable_flux_sink();

  public:
  // optional .DriveProto drive = 12 [json_name = "drive"];
  [[nodiscard]] bool has_drive() const;
  void clear_drive() ;
  [[nodiscard]] const ::DriveProto& drive() const;
  [[nodiscard]] ::DriveProto* PROTOBUF_NULLABLE release_drive();
  ::DriveProto* PROTOBUF_NONNULL mutable_drive();
  void set_allocated_drive(::DriveProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_drive(::DriveProto* PROTOBUF_NULLABLE value);
  ::DriveProto* PROTOBUF_NULLABLE unsafe_arena_release_drive();

  private:
  const ::DriveProto& _internal_drive() const;
  ::DriveProto* PROTOBUF_NONNULL _internal_mutable_drive();

  public:
  // optional .EncoderProto encoder = 13 [json_name = "encoder"];
  [[nodiscard]] bool has_encoder() const;
  void clear_encoder() ;
  [[nodiscard]] const ::EncoderProto& encoder() const;
  [[nodiscard]] ::EncoderProto* PROTOBUF_NULLABLE release_encoder();
  ::EncoderProto* PROTOBUF_NONNULL mutable_encoder();
  void set_allocated_encoder(::EncoderProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_encoder(::EncoderProto* PROTOBUF_NULLABLE value);
  ::EncoderProto* PROTOBUF_NULLABLE unsafe_arena_release_encoder();

  private:
  const ::EncoderProto& _internal_encoder() const;
  ::EncoderProto* PROTOBUF_NONNULL _internal_mutable_encoder();

  public:
  // optional .DecoderProto decoder = 14 [json_name = "decoder"];
  [[nodiscard]] bool has_decoder() const;
  void clear_decoder() ;
  [[nodiscard]] const ::DecoderProto& decoder() const;
  [[nodiscard]] ::DecoderProto* PROTOBUF_NULLABLE release_decoder();
  ::DecoderProto* PROTOBUF_NONNULL mutable_decoder();
  void set_allocated_decoder(::DecoderProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_decoder(::DecoderProto* PROTOBUF_NULLABLE value);
  ::DecoderProto* PROTOBUF_NULLABLE unsafe_arena_release_decoder();

  private:
  const ::DecoderProto& _internal_decoder() const;
  ::DecoderProto* PROTOBUF_NONNULL _internal_mutable_decoder();

  public:
  // optional .UsbProto usb = 15 [json_name = "usb"];
  [[nodiscard]] bool has_usb() const;
  void clear_usb() ;
  [[nodiscard]] const ::UsbProto& usb() const;
  [[nodiscard]] ::UsbProto* PROTOBUF_NULLABLE release_usb();
  ::UsbProto* PROTOBUF_NONNULL mutable_usb();
  void set_allocated_usb(::UsbProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_usb(::UsbProto* PROTOBUF_NULLABLE value);
  ::UsbProto* PROTOBUF_NULLABLE unsafe_arena_release_usb();

  private:
  const ::UsbProto& _internal_usb() const;
  ::UsbProto* PROTOBUF_NONNULL _internal_mutable_usb();

  public:
  // optional .FilesystemProto filesystem = 18 [json_name = "filesystem"];
  [[nodiscard]] bool has_filesystem() const;
  void clear_filesystem() ;
  [[nodiscard]] const ::FilesystemProto& filesystem() const;
  [[nodiscard]] ::FilesystemProto* PROTOBUF_NULLABLE release_filesystem();
  ::FilesystemProto* PROTOBUF_NONNULL mutable_filesystem();
  void set_allocated_filesystem(::FilesystemProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_filesystem(::FilesystemProto* PROTOBUF_NULLABLE value);
  ::FilesystemProto* PROTOBUF_NULLABLE unsafe_arena_release_filesystem();

  private:
  const ::FilesystemProto& _internal_filesystem() const;
  ::FilesystemProto* PROTOBUF_NONNULL _internal_mutable_filesystem();

  public:
  // optional bool is_extension = 3 [json_name = "isExtension"];
  [[nodiscard]] bool has_is_extension() const;
  void clear_is_extension() ;
  [[nodiscard]] bool is_extension() const;
  void set_is_extension(bool value);

  private:
  bool _internal_is_extension() const;
  void _internal_set_is_extension(bool value);

  public:
  // optional .SupportStatus read_support_status = 5 [default = UNSUPPORTED, json_name = "readSupportStatus"];
  [[nodiscard]] bool has_read_support_status() const;
  void clear_read_support_status() ;
  [[nodiscard]] ::SupportStatus read_support_status() const;
  void set_read_support_status(::SupportStatus value);

  private:
  ::SupportStatus _internal_read_support_status() const;
  void _internal_set_read_support_status(::SupportStatus value);

  public:
  // optional .SupportStatus write_support_status = 6 [default = UNSUPPORTED, json_name = "writeSupportStatus"];
  [[nodiscard]] bool has_write_support_status() const;
  void clear_write_support_status() ;
  [[nodiscard]] ::SupportStatus write_support_status() const;
  void set_write_support_status(::SupportStatus value);

  private:
  ::SupportStatus _internal_write_support_status() const;
  void _internal_set_write_support_status(::SupportStatus value);

  public:
  // @@protoc_insertion_point(class_scope:ConfigProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 19,
                          14, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ConfigProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> documentation_;
    ::google::protobuf::RepeatedPtrField< ::OptionProto > option_;
    ::google::protobuf::RepeatedPtrField< ::OptionGroupProto > option_group_;
    ::google::protobuf::internal::ArenaStringPtr shortname_;
    ::google::protobuf::internal::ArenaStringPtr comment_;
    ::google::protobuf::internal::ArenaStringPtr tracks_;
    ::LayoutProto* PROTOBUF_NULLABLE layout_;
    ::ImageReaderProto* PROTOBUF_NULLABLE image_reader_;
    ::ImageWriterProto* PROTOBUF_NULLABLE image_writer_;
    ::FluxSourceProto* PROTOBUF_NULLABLE flux_source_;
    ::FluxSinkProto* PROTOBUF_NULLABLE flux_sink_;
    ::DriveProto* PROTOBUF_NULLABLE drive_;
    ::EncoderProto* PROTOBUF_NULLABLE encoder_;
    ::DecoderProto* PROTOBUF_NULLABLE decoder_;
    ::UsbProto* PROTOBUF_NULLABLE usb_;
    ::FilesystemProto* PROTOBUF_NULLABLE filesystem_;
    bool is_extension_;
    int read_support_status_;
    int write_support_status_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fconfig_2fconfig_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED OptionGroupProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:OptionGroupProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline OptionGroupProto() : OptionGroupProto(nullptr) {}
  ~OptionGroupProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(OptionGroupProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(OptionGroupProto));
  }
#endif

  template <typename = void>
  explicit constexpr OptionGroupProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline OptionGroupProto(const OptionGroupProto& from) : OptionGroupProto(nullptr, from) {}
  inline OptionGroupProto(OptionGroupProto&& from) noexcept : OptionGroupProto(nullptr, ::std::move(from)) {}
  inline OptionGroupProto& operator=(const OptionGroupProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline OptionGroupProto& operator=(OptionGroupProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const OptionGroupProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<OptionGroupProto>(&OptionGroupProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(OptionGroupProto& a, OptionGroupProto& b) { a.Swap(&b); }
  inline void Swap(OptionGroupProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OptionGroupProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] OptionGroupProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<OptionGroupProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const OptionGroupProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const OptionGroupProto& from) { OptionGroupProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(OptionGroupProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "OptionGroupProto"; }

  explicit OptionGroupProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  OptionGroupProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionGroupProto& from);
  OptionGroupProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OptionGroupProto&& from) noexcept
      : OptionGroupProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kOptionFieldNumber = 3,
    kApplicabilityFieldNumber = 4,
    kCommentFieldNumber = 1,
    kNameFieldNumber = 2,
  };
  // repeated .OptionProto option = 3 [json_name = "option"];
  [[nodiscard]] int option_size() const;
  private:
  int _internal_option_size() const;

  public:
  void clear_option() ;
  [[nodiscard]] const ::OptionProto& option(int index) const;
  [[nodiscard]] ::OptionProto* PROTOBUF_NONNULL mutable_option(int index);
  ::OptionProto* PROTOBUF_NONNULL add_option();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::OptionProto>&
  option() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL
  mutable_option();

  private:
  const ::google::protobuf::RepeatedPtrField<::OptionProto>& _internal_option() const;
  ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL _internal_mutable_option();

  public:
  // repeated .OptionApplicabilityHint applicability = 4 [json_name = "applicability"];
  [[nodiscard]] int applicability_size() const;
  private:
  int _internal_applicability_size() const;

  public:
  void clear_applicability() ;
  public:
  [[nodiscard]] ::OptionApplicabilityHint applicability(int index) const;
  void set_applicability(int index, ::OptionApplicabilityHint value);
  void add_applicability(::OptionApplicabilityHint value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<int>& applicability()
      const;
  [[nodiscard]] ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL mutable_applicability();

  private:
  const ::google::protobuf::RepeatedField<int>& _internal_applicability() const;
  ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL _internal_mutable_applicability();

  public:
  // optional string comment = 1 [json_name = "comment", (.help) = "help text for option group"];
  [[nodiscard]] bool has_comment() const;
  void clear_comment() ;
  [[nodiscard]] const ::std::string& comment() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_comment(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_comment();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_comment();
  void set_allocated_comment(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_comment() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_comment();

  public:
  // optional string name = 2 [json_name = "name", (.help) = "option group name"];
  [[nodiscard]] bool has_name() const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // @@protoc_insertion_point(class_scope:OptionGroupProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          2, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const OptionGroupProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::OptionProto > option_;
    ::google::protobuf::RepeatedField<int> applicability_;
    ::google::protobuf::internal::ArenaStringPtr comment_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fconfig_2fconfig_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED OptionProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:OptionProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline OptionProto() : OptionProto(nullptr) {}
  ~OptionProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(OptionProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(OptionProto));
  }
#endif

  template <typename = void>
  explicit constexpr OptionProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline OptionProto(const OptionProto& from) : OptionProto(nullptr, from) {}
  inline OptionProto(OptionProto&& from) noexcept : OptionProto(nullptr, ::std::move(from)) {}
  inline OptionProto& operator=(const OptionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline OptionProto& operator=(OptionProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const OptionProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<OptionProto>(&OptionProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(OptionProto& a, OptionProto& b) { a.Swap(&b); }
  inline void Swap(OptionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OptionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] OptionProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<OptionProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const OptionProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const OptionProto& from) { OptionProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(OptionProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "OptionProto"; }

  explicit OptionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  OptionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionProto& from);
  OptionProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OptionProto&& from) noexcept
      : OptionProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kPrerequisiteFieldNumber = 7,
    kApplicabilityFieldNumber = 8,
    kNameFieldNumber = 1,
    kCommentFieldNumber = 2,
    kMessageFieldNumber = 3,
    kConfigFieldNumber = 4,
    kSetByDefaultFieldNumber = 6,
  };
  // repeated .OptionPrerequisiteProto prerequisite = 7 [json_name = "prerequisite", (.help) = "prerequisites for this option"];
  [[nodiscard]] int prerequisite_size() const;
  private:
  int _internal_prerequisite_size() const;

  public:
  void clear_prerequisite() ;
  [[nodiscard]] const ::OptionPrerequisiteProto& prerequisite(int index) const;
  [[nodiscard]] ::OptionPrerequisiteProto* PROTOBUF_NONNULL mutable_prerequisite(int index);
  ::OptionPrerequisiteProto* PROTOBUF_NONNULL add_prerequisite();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>&
  prerequisite() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>* PROTOBUF_NONNULL
  mutable_prerequisite();

  private:
  const ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>& _internal_prerequisite() const;
  ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>* PROTOBUF_NONNULL _internal_mutable_prerequisite();

  public:
  // repeated .OptionApplicabilityHint applicability = 8 [json_name = "applicability"];
  [[nodiscard]] int applicability_size() const;
  private:
  int _internal_applicability_size() const;

  public:
  void clear_applicability() ;
  public:
  [[nodiscard]] ::OptionApplicabilityHint applicability(int index) const;
  void set_applicability(int index, ::OptionApplicabilityHint value);
  void add_applicability(::OptionApplicabilityHint value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<int>& applicability()
      const;
  [[nodiscard]] ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL mutable_applicability();

  private:
  const ::google::protobuf::RepeatedField<int>& _internal_applicability() const;
  ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL _internal_mutable_applicability();

  public:
  // optional string name = 1 [json_name = "name", (.help) = "option name"];
  [[nodiscard]] bool has_name() const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional string comment = 2 [json_name = "comment", (.help) = "help text for option"];
  [[nodiscard]] bool has_comment() const;
  void clear_comment() ;
  [[nodiscard]] const ::std::string& comment() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_comment(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_comment();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_comment();
  void set_allocated_comment(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_comment() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_comment();

  public:
  // optional string message = 3 [json_name = "message", (.help) = "message to display when option is in use"];
  [[nodiscard]] bool has_message() const;
  void clear_message() ;
  [[nodiscard]] const ::std::string& message() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_message(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_message();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_message();
  void set_allocated_message(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_message() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_message(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_message();

  public:
  // optional .ConfigProto config = 4 [json_name = "config", (.help) = "option data"];
  [[nodiscard]] bool has_config() const;
  void clear_config() ;
  [[nodiscard]] const ::ConfigProto& config() const;
  [[nodiscard]] ::ConfigProto* PROTOBUF_NULLABLE release_config();
  ::ConfigProto* PROTOBUF_NONNULL mutable_config();
  void set_allocated_config(::ConfigProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_config(::ConfigProto* PROTOBUF_NULLABLE value);
  ::ConfigProto* PROTOBUF_NULLABLE unsafe_arena_release_config();

  private:
  const ::ConfigProto& _internal_config() const;
  ::ConfigProto* PROTOBUF_NONNULL _internal_mutable_config();

  public:
  // optional bool set_by_default = 6 [default = false, json_name = "setByDefault", (.help) = "this option is applied by default"];
  [[nodiscard]] bool has_set_by_default() const;
  void clear_set_by_default() ;
  [[nodiscard]] bool set_by_default() const;
  void set_set_by_default(bool value);

  private:
  bool _internal_set_by_default() const;
  void _internal_set_set_by_default(bool value);

  public:
  // @@protoc_insertion_point(class_scope:OptionProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 7,
                          3, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const OptionProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::OptionPrerequisiteProto > prerequisite_;
    ::google::protobuf::RepeatedField<int> applicability_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr comment_;
    ::google::protobuf::internal::ArenaStringPtr message_;
    ::ConfigProto* PROTOBUF_NULLABLE config_;
    bool set_by_default_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fconfig_2fconfig_2eproto;
};

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




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


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

// ConfigProto

// optional string shortname = 1 [json_name = "shortname"];
inline bool ConfigProto::has_shortname() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void ConfigProto::clear_shortname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shortname_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& ConfigProto::shortname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.shortname)
  return _internal_shortname();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ConfigProto::set_shortname(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.shortname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:ConfigProto.shortname)
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::mutable_shortname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_shortname();
  // @@protoc_insertion_point(field_mutable:ConfigProto.shortname)
  return _s;
}
inline const ::std::string& ConfigProto::_internal_shortname() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shortname_.Get();
}
inline void ConfigProto::_internal_set_shortname(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shortname_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::_internal_mutable_shortname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.shortname_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ConfigProto::release_shortname() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.shortname)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.shortname_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.shortname_.Set("", GetArena());
  }
  return released;
}
inline void ConfigProto::set_allocated_shortname(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.shortname_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.shortname_.IsDefault()) {
    _impl_.shortname_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.shortname)
}

// optional string comment = 2 [json_name = "comment"];
inline bool ConfigProto::has_comment() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void ConfigProto::clear_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& ConfigProto::comment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.comment)
  return _internal_comment();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ConfigProto::set_comment(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.comment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:ConfigProto.comment)
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::mutable_comment()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:ConfigProto.comment)
  return _s;
}
inline const ::std::string& ConfigProto::_internal_comment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.comment_.Get();
}
inline void ConfigProto::_internal_set_comment(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::_internal_mutable_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.comment_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ConfigProto::release_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.comment)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.comment_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.comment_.Set("", GetArena());
  }
  return released;
}
inline void ConfigProto::set_allocated_comment(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.comment_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.comment_.IsDefault()) {
    _impl_.comment_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.comment)
}

// optional bool is_extension = 3 [json_name = "isExtension"];
inline bool ConfigProto::has_is_extension() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void ConfigProto::clear_is_extension() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_extension_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline bool ConfigProto::is_extension() const {
  // @@protoc_insertion_point(field_get:ConfigProto.is_extension)
  return _internal_is_extension();
}
inline void ConfigProto::set_is_extension(bool value) {
  _internal_set_is_extension(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:ConfigProto.is_extension)
}
inline bool ConfigProto::_internal_is_extension() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.is_extension_;
}
inline void ConfigProto::_internal_set_is_extension(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.is_extension_ = value;
}

// repeated string documentation = 4 [json_name = "documentation"];
inline int ConfigProto::_internal_documentation_size() const {
  return _internal_documentation().size();
}
inline int ConfigProto::documentation_size() const {
  return _internal_documentation_size();
}
inline void ConfigProto::clear_documentation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.documentation_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::add_documentation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_documentation()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:ConfigProto.documentation)
  return _s;
}
inline const ::std::string& ConfigProto::documentation(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.documentation)
  return _internal_documentation().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::mutable_documentation(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:ConfigProto.documentation)
  return _internal_mutable_documentation()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void ConfigProto::set_documentation(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_documentation()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:ConfigProto.documentation)
}
template <typename Arg_, typename... Args_>
inline void ConfigProto::add_documentation(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_documentation(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:ConfigProto.documentation)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& ConfigProto::documentation()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:ConfigProto.documentation)
  return _internal_documentation();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
ConfigProto::mutable_documentation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:ConfigProto.documentation)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_documentation();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
ConfigProto::_internal_documentation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.documentation_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
ConfigProto::_internal_mutable_documentation() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.documentation_;
}

// optional .SupportStatus read_support_status = 5 [default = UNSUPPORTED, json_name = "readSupportStatus"];
inline bool ConfigProto::has_read_support_status() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void ConfigProto::clear_read_support_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.read_support_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline ::SupportStatus ConfigProto::read_support_status() const {
  // @@protoc_insertion_point(field_get:ConfigProto.read_support_status)
  return _internal_read_support_status();
}
inline void ConfigProto::set_read_support_status(::SupportStatus value) {
  _internal_set_read_support_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:ConfigProto.read_support_status)
}
inline ::SupportStatus ConfigProto::_internal_read_support_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::SupportStatus>(_impl_.read_support_status_);
}
inline void ConfigProto::_internal_set_read_support_status(::SupportStatus value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::SupportStatus_internal_data_));
                                          _impl_.read_support_status_ = value;
}

// optional .SupportStatus write_support_status = 6 [default = UNSUPPORTED, json_name = "writeSupportStatus"];
inline bool ConfigProto::has_write_support_status() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  return value;
}
inline void ConfigProto::clear_write_support_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.write_support_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline ::SupportStatus ConfigProto::write_support_status() const {
  // @@protoc_insertion_point(field_get:ConfigProto.write_support_status)
  return _internal_write_support_status();
}
inline void ConfigProto::set_write_support_status(::SupportStatus value) {
  _internal_set_write_support_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:ConfigProto.write_support_status)
}
inline ::SupportStatus ConfigProto::_internal_write_support_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::SupportStatus>(_impl_.write_support_status_);
}
inline void ConfigProto::_internal_set_write_support_status(::SupportStatus value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::SupportStatus_internal_data_));
                                          _impl_.write_support_status_ = value;
}

// optional .LayoutProto layout = 7 [json_name = "layout"];
inline bool ConfigProto::has_layout() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.layout_ != nullptr);
  return value;
}
inline const ::LayoutProto& ConfigProto::_internal_layout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::LayoutProto* p = _impl_.layout_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::LayoutProto>(&::LayoutProto_globals_);
}
inline const ::LayoutProto& ConfigProto::layout() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.layout)
  return _internal_layout();
}
inline void ConfigProto::unsafe_arena_set_allocated_layout(
    ::LayoutProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.layout_);
  }
  _impl_.layout_ = reinterpret_cast<::LayoutProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.layout)
}
inline ::LayoutProto* PROTOBUF_NULLABLE ConfigProto::release_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::LayoutProto* released = _impl_.layout_;
  _impl_.layout_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::LayoutProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.layout)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::LayoutProto* temp = _impl_.layout_;
  _impl_.layout_ = nullptr;
  return temp;
}
inline ::LayoutProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_layout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.layout_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::LayoutProto>(GetArena());
    _impl_.layout_ = reinterpret_cast<::LayoutProto*>(p);
  }
  return _impl_.layout_;
}
inline ::LayoutProto* PROTOBUF_NONNULL ConfigProto::mutable_layout()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::LayoutProto* _msg = _internal_mutable_layout();
  // @@protoc_insertion_point(field_mutable:ConfigProto.layout)
  return _msg;
}
inline void ConfigProto::set_allocated_layout(::LayoutProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.layout_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }

  _impl_.layout_ = reinterpret_cast<::LayoutProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.layout)
}

// optional .ImageReaderProto image_reader = 8 [json_name = "imageReader"];
inline bool ConfigProto::has_image_reader() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.image_reader_ != nullptr);
  return value;
}
inline const ::ImageReaderProto& ConfigProto::_internal_image_reader() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ImageReaderProto* p = _impl_.image_reader_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ImageReaderProto>(&::ImageReaderProto_globals_);
}
inline const ::ImageReaderProto& ConfigProto::image_reader() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.image_reader)
  return _internal_image_reader();
}
inline void ConfigProto::unsafe_arena_set_allocated_image_reader(
    ::ImageReaderProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.image_reader_);
  }
  _impl_.image_reader_ = reinterpret_cast<::ImageReaderProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.image_reader)
}
inline ::ImageReaderProto* PROTOBUF_NULLABLE ConfigProto::release_image_reader() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::ImageReaderProto* released = _impl_.image_reader_;
  _impl_.image_reader_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::ImageReaderProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_image_reader() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.image_reader)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::ImageReaderProto* temp = _impl_.image_reader_;
  _impl_.image_reader_ = nullptr;
  return temp;
}
inline ::ImageReaderProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_image_reader() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.image_reader_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ImageReaderProto>(GetArena());
    _impl_.image_reader_ = reinterpret_cast<::ImageReaderProto*>(p);
  }
  return _impl_.image_reader_;
}
inline ::ImageReaderProto* PROTOBUF_NONNULL ConfigProto::mutable_image_reader()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::ImageReaderProto* _msg = _internal_mutable_image_reader();
  // @@protoc_insertion_point(field_mutable:ConfigProto.image_reader)
  return _msg;
}
inline void ConfigProto::set_allocated_image_reader(::ImageReaderProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.image_reader_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }

  _impl_.image_reader_ = reinterpret_cast<::ImageReaderProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.image_reader)
}

// optional .ImageWriterProto image_writer = 9 [json_name = "imageWriter"];
inline bool ConfigProto::has_image_writer() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.image_writer_ != nullptr);
  return value;
}
inline const ::ImageWriterProto& ConfigProto::_internal_image_writer() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ImageWriterProto* p = _impl_.image_writer_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ImageWriterProto>(&::ImageWriterProto_globals_);
}
inline const ::ImageWriterProto& ConfigProto::image_writer() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.image_writer)
  return _internal_image_writer();
}
inline void ConfigProto::unsafe_arena_set_allocated_image_writer(
    ::ImageWriterProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.image_writer_);
  }
  _impl_.image_writer_ = reinterpret_cast<::ImageWriterProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.image_writer)
}
inline ::ImageWriterProto* PROTOBUF_NULLABLE ConfigProto::release_image_writer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::ImageWriterProto* released = _impl_.image_writer_;
  _impl_.image_writer_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::ImageWriterProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_image_writer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.image_writer)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::ImageWriterProto* temp = _impl_.image_writer_;
  _impl_.image_writer_ = nullptr;
  return temp;
}
inline ::ImageWriterProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_image_writer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.image_writer_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ImageWriterProto>(GetArena());
    _impl_.image_writer_ = reinterpret_cast<::ImageWriterProto*>(p);
  }
  return _impl_.image_writer_;
}
inline ::ImageWriterProto* PROTOBUF_NONNULL ConfigProto::mutable_image_writer()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::ImageWriterProto* _msg = _internal_mutable_image_writer();
  // @@protoc_insertion_point(field_mutable:ConfigProto.image_writer)
  return _msg;
}
inline void ConfigProto::set_allocated_image_writer(::ImageWriterProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.image_writer_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }

  _impl_.image_writer_ = reinterpret_cast<::ImageWriterProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.image_writer)
}

// optional .FluxSourceProto flux_source = 10 [json_name = "fluxSource"];
inline bool ConfigProto::has_flux_source() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.flux_source_ != nullptr);
  return value;
}
inline const ::FluxSourceProto& ConfigProto::_internal_flux_source() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::FluxSourceProto* p = _impl_.flux_source_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::FluxSourceProto>(&::FluxSourceProto_globals_);
}
inline const ::FluxSourceProto& ConfigProto::flux_source() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.flux_source)
  return _internal_flux_source();
}
inline void ConfigProto::unsafe_arena_set_allocated_flux_source(
    ::FluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.flux_source_);
  }
  _impl_.flux_source_ = reinterpret_cast<::FluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.flux_source)
}
inline ::FluxSourceProto* PROTOBUF_NULLABLE ConfigProto::release_flux_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::FluxSourceProto* released = _impl_.flux_source_;
  _impl_.flux_source_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::FluxSourceProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_flux_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.flux_source)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::FluxSourceProto* temp = _impl_.flux_source_;
  _impl_.flux_source_ = nullptr;
  return temp;
}
inline ::FluxSourceProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_flux_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.flux_source_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::FluxSourceProto>(GetArena());
    _impl_.flux_source_ = reinterpret_cast<::FluxSourceProto*>(p);
  }
  return _impl_.flux_source_;
}
inline ::FluxSourceProto* PROTOBUF_NONNULL ConfigProto::mutable_flux_source()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::FluxSourceProto* _msg = _internal_mutable_flux_source();
  // @@protoc_insertion_point(field_mutable:ConfigProto.flux_source)
  return _msg;
}
inline void ConfigProto::set_allocated_flux_source(::FluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.flux_source_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }

  _impl_.flux_source_ = reinterpret_cast<::FluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.flux_source)
}

// optional .FluxSinkProto flux_sink = 11 [json_name = "fluxSink"];
inline bool ConfigProto::has_flux_sink() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.flux_sink_ != nullptr);
  return value;
}
inline const ::FluxSinkProto& ConfigProto::_internal_flux_sink() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::FluxSinkProto* p = _impl_.flux_sink_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::FluxSinkProto>(&::FluxSinkProto_globals_);
}
inline const ::FluxSinkProto& ConfigProto::flux_sink() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.flux_sink)
  return _internal_flux_sink();
}
inline void ConfigProto::unsafe_arena_set_allocated_flux_sink(
    ::FluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.flux_sink_);
  }
  _impl_.flux_sink_ = reinterpret_cast<::FluxSinkProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.flux_sink)
}
inline ::FluxSinkProto* PROTOBUF_NULLABLE ConfigProto::release_flux_sink() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::FluxSinkProto* released = _impl_.flux_sink_;
  _impl_.flux_sink_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::FluxSinkProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_flux_sink() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.flux_sink)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::FluxSinkProto* temp = _impl_.flux_sink_;
  _impl_.flux_sink_ = nullptr;
  return temp;
}
inline ::FluxSinkProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_flux_sink() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.flux_sink_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::FluxSinkProto>(GetArena());
    _impl_.flux_sink_ = reinterpret_cast<::FluxSinkProto*>(p);
  }
  return _impl_.flux_sink_;
}
inline ::FluxSinkProto* PROTOBUF_NONNULL ConfigProto::mutable_flux_sink()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::FluxSinkProto* _msg = _internal_mutable_flux_sink();
  // @@protoc_insertion_point(field_mutable:ConfigProto.flux_sink)
  return _msg;
}
inline void ConfigProto::set_allocated_flux_sink(::FluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.flux_sink_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }

  _impl_.flux_sink_ = reinterpret_cast<::FluxSinkProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.flux_sink)
}

// optional .DriveProto drive = 12 [json_name = "drive"];
inline bool ConfigProto::has_drive() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  PROTOBUF_ASSUME(!value || _impl_.drive_ != nullptr);
  return value;
}
inline const ::DriveProto& ConfigProto::_internal_drive() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::DriveProto* p = _impl_.drive_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::DriveProto>(&::DriveProto_globals_);
}
inline const ::DriveProto& ConfigProto::drive() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.drive)
  return _internal_drive();
}
inline void ConfigProto::unsafe_arena_set_allocated_drive(
    ::DriveProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.drive_);
  }
  _impl_.drive_ = reinterpret_cast<::DriveProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.drive)
}
inline ::DriveProto* PROTOBUF_NULLABLE ConfigProto::release_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::DriveProto* released = _impl_.drive_;
  _impl_.drive_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::DriveProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.drive)

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::DriveProto* temp = _impl_.drive_;
  _impl_.drive_ = nullptr;
  return temp;
}
inline ::DriveProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.drive_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::DriveProto>(GetArena());
    _impl_.drive_ = reinterpret_cast<::DriveProto*>(p);
  }
  return _impl_.drive_;
}
inline ::DriveProto* PROTOBUF_NONNULL ConfigProto::mutable_drive()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::DriveProto* _msg = _internal_mutable_drive();
  // @@protoc_insertion_point(field_mutable:ConfigProto.drive)
  return _msg;
}
inline void ConfigProto::set_allocated_drive(::DriveProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.drive_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }

  _impl_.drive_ = reinterpret_cast<::DriveProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.drive)
}

// optional .EncoderProto encoder = 13 [json_name = "encoder"];
inline bool ConfigProto::has_encoder() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  PROTOBUF_ASSUME(!value || _impl_.encoder_ != nullptr);
  return value;
}
inline const ::EncoderProto& ConfigProto::_internal_encoder() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::EncoderProto* p = _impl_.encoder_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::EncoderProto>(&::EncoderProto_globals_);
}
inline const ::EncoderProto& ConfigProto::encoder() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.encoder)
  return _internal_encoder();
}
inline void ConfigProto::unsafe_arena_set_allocated_encoder(
    ::EncoderProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.encoder_);
  }
  _impl_.encoder_ = reinterpret_cast<::EncoderProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.encoder)
}
inline ::EncoderProto* PROTOBUF_NULLABLE ConfigProto::release_encoder() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::EncoderProto* released = _impl_.encoder_;
  _impl_.encoder_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::EncoderProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_encoder() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.encoder)

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::EncoderProto* temp = _impl_.encoder_;
  _impl_.encoder_ = nullptr;
  return temp;
}
inline ::EncoderProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_encoder() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.encoder_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::EncoderProto>(GetArena());
    _impl_.encoder_ = reinterpret_cast<::EncoderProto*>(p);
  }
  return _impl_.encoder_;
}
inline ::EncoderProto* PROTOBUF_NONNULL ConfigProto::mutable_encoder()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::EncoderProto* _msg = _internal_mutable_encoder();
  // @@protoc_insertion_point(field_mutable:ConfigProto.encoder)
  return _msg;
}
inline void ConfigProto::set_allocated_encoder(::EncoderProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.encoder_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }

  _impl_.encoder_ = reinterpret_cast<::EncoderProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.encoder)
}

// optional .DecoderProto decoder = 14 [json_name = "decoder"];
inline bool ConfigProto::has_decoder() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  PROTOBUF_ASSUME(!value || _impl_.decoder_ != nullptr);
  return value;
}
inline const ::DecoderProto& ConfigProto::_internal_decoder() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::DecoderProto* p = _impl_.decoder_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::DecoderProto>(&::DecoderProto_globals_);
}
inline const ::DecoderProto& ConfigProto::decoder() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.decoder)
  return _internal_decoder();
}
inline void ConfigProto::unsafe_arena_set_allocated_decoder(
    ::DecoderProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.decoder_);
  }
  _impl_.decoder_ = reinterpret_cast<::DecoderProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.decoder)
}
inline ::DecoderProto* PROTOBUF_NULLABLE ConfigProto::release_decoder() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::DecoderProto* released = _impl_.decoder_;
  _impl_.decoder_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::DecoderProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_decoder() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.decoder)

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::DecoderProto* temp = _impl_.decoder_;
  _impl_.decoder_ = nullptr;
  return temp;
}
inline ::DecoderProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_decoder() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.decoder_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::DecoderProto>(GetArena());
    _impl_.decoder_ = reinterpret_cast<::DecoderProto*>(p);
  }
  return _impl_.decoder_;
}
inline ::DecoderProto* PROTOBUF_NONNULL ConfigProto::mutable_decoder()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::DecoderProto* _msg = _internal_mutable_decoder();
  // @@protoc_insertion_point(field_mutable:ConfigProto.decoder)
  return _msg;
}
inline void ConfigProto::set_allocated_decoder(::DecoderProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.decoder_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }

  _impl_.decoder_ = reinterpret_cast<::DecoderProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.decoder)
}

// optional .UsbProto usb = 15 [json_name = "usb"];
inline bool ConfigProto::has_usb() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  PROTOBUF_ASSUME(!value || _impl_.usb_ != nullptr);
  return value;
}
inline const ::UsbProto& ConfigProto::_internal_usb() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::UsbProto* p = _impl_.usb_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::UsbProto>(&::UsbProto_globals_);
}
inline const ::UsbProto& ConfigProto::usb() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.usb)
  return _internal_usb();
}
inline void ConfigProto::unsafe_arena_set_allocated_usb(
    ::UsbProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.usb_);
  }
  _impl_.usb_ = reinterpret_cast<::UsbProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.usb)
}
inline ::UsbProto* PROTOBUF_NULLABLE ConfigProto::release_usb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::UsbProto* released = _impl_.usb_;
  _impl_.usb_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::UsbProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_usb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.usb)

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::UsbProto* temp = _impl_.usb_;
  _impl_.usb_ = nullptr;
  return temp;
}
inline ::UsbProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_usb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.usb_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::UsbProto>(GetArena());
    _impl_.usb_ = reinterpret_cast<::UsbProto*>(p);
  }
  return _impl_.usb_;
}
inline ::UsbProto* PROTOBUF_NONNULL ConfigProto::mutable_usb()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::UsbProto* _msg = _internal_mutable_usb();
  // @@protoc_insertion_point(field_mutable:ConfigProto.usb)
  return _msg;
}
inline void ConfigProto::set_allocated_usb(::UsbProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.usb_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }

  _impl_.usb_ = reinterpret_cast<::UsbProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.usb)
}

// optional string tracks = 16 [json_name = "tracks"];
inline bool ConfigProto::has_tracks() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void ConfigProto::clear_tracks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tracks_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& ConfigProto::tracks() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.tracks)
  return _internal_tracks();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ConfigProto::set_tracks(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.tracks_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:ConfigProto.tracks)
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::mutable_tracks()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_tracks();
  // @@protoc_insertion_point(field_mutable:ConfigProto.tracks)
  return _s;
}
inline const ::std::string& ConfigProto::_internal_tracks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tracks_.Get();
}
inline void ConfigProto::_internal_set_tracks(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tracks_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ConfigProto::_internal_mutable_tracks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.tracks_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ConfigProto::release_tracks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.tracks)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.tracks_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.tracks_.Set("", GetArena());
  }
  return released;
}
inline void ConfigProto::set_allocated_tracks(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.tracks_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.tracks_.IsDefault()) {
    _impl_.tracks_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.tracks)
}

// optional .FilesystemProto filesystem = 18 [json_name = "filesystem"];
inline bool ConfigProto::has_filesystem() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  PROTOBUF_ASSUME(!value || _impl_.filesystem_ != nullptr);
  return value;
}
inline const ::FilesystemProto& ConfigProto::_internal_filesystem() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::FilesystemProto* p = _impl_.filesystem_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::FilesystemProto>(&::FilesystemProto_globals_);
}
inline const ::FilesystemProto& ConfigProto::filesystem() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.filesystem)
  return _internal_filesystem();
}
inline void ConfigProto::unsafe_arena_set_allocated_filesystem(
    ::FilesystemProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.filesystem_);
  }
  _impl_.filesystem_ = reinterpret_cast<::FilesystemProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ConfigProto.filesystem)
}
inline ::FilesystemProto* PROTOBUF_NULLABLE ConfigProto::release_filesystem() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::FilesystemProto* released = _impl_.filesystem_;
  _impl_.filesystem_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::FilesystemProto* PROTOBUF_NULLABLE ConfigProto::unsafe_arena_release_filesystem() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ConfigProto.filesystem)

  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::FilesystemProto* temp = _impl_.filesystem_;
  _impl_.filesystem_ = nullptr;
  return temp;
}
inline ::FilesystemProto* PROTOBUF_NONNULL ConfigProto::_internal_mutable_filesystem() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.filesystem_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::FilesystemProto>(GetArena());
    _impl_.filesystem_ = reinterpret_cast<::FilesystemProto*>(p);
  }
  return _impl_.filesystem_;
}
inline ::FilesystemProto* PROTOBUF_NONNULL ConfigProto::mutable_filesystem()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::FilesystemProto* _msg = _internal_mutable_filesystem();
  // @@protoc_insertion_point(field_mutable:ConfigProto.filesystem)
  return _msg;
}
inline void ConfigProto::set_allocated_filesystem(::FilesystemProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.filesystem_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }

  _impl_.filesystem_ = reinterpret_cast<::FilesystemProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ConfigProto.filesystem)
}

// repeated .OptionProto option = 19 [json_name = "option"];
inline int ConfigProto::_internal_option_size() const {
  return _internal_option().size();
}
inline int ConfigProto::option_size() const {
  return _internal_option_size();
}
inline void ConfigProto::clear_option() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.option_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::OptionProto& ConfigProto::option(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.option)
  return _internal_option().Get(index);
}
inline ::OptionProto* PROTOBUF_NONNULL ConfigProto::mutable_option(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:ConfigProto.option)
  return _internal_mutable_option()->Mutable(index);
}
inline ::OptionProto* PROTOBUF_NONNULL ConfigProto::add_option()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::OptionProto* _add =
      _internal_mutable_option()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:ConfigProto.option)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::OptionProto>& ConfigProto::option() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:ConfigProto.option)
  return _internal_option();
}
inline ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL
ConfigProto::mutable_option() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:ConfigProto.option)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_option();
}
inline const ::google::protobuf::RepeatedPtrField<::OptionProto>&
ConfigProto::_internal_option() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.option_;
}
inline ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL
ConfigProto::_internal_mutable_option() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.option_;
}

// repeated .OptionGroupProto option_group = 20 [json_name = "optionGroup"];
inline int ConfigProto::_internal_option_group_size() const {
  return _internal_option_group().size();
}
inline int ConfigProto::option_group_size() const {
  return _internal_option_group_size();
}
inline void ConfigProto::clear_option_group() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.option_group_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::OptionGroupProto& ConfigProto::option_group(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ConfigProto.option_group)
  return _internal_option_group().Get(index);
}
inline ::OptionGroupProto* PROTOBUF_NONNULL ConfigProto::mutable_option_group(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:ConfigProto.option_group)
  return _internal_mutable_option_group()->Mutable(index);
}
inline ::OptionGroupProto* PROTOBUF_NONNULL ConfigProto::add_option_group()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::OptionGroupProto* _add =
      _internal_mutable_option_group()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:ConfigProto.option_group)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::OptionGroupProto>& ConfigProto::option_group() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:ConfigProto.option_group)
  return _internal_option_group();
}
inline ::google::protobuf::RepeatedPtrField<::OptionGroupProto>* PROTOBUF_NONNULL
ConfigProto::mutable_option_group() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:ConfigProto.option_group)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_option_group();
}
inline const ::google::protobuf::RepeatedPtrField<::OptionGroupProto>&
ConfigProto::_internal_option_group() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.option_group_;
}
inline ::google::protobuf::RepeatedPtrField<::OptionGroupProto>* PROTOBUF_NONNULL
ConfigProto::_internal_mutable_option_group() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.option_group_;
}

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

// OptionPrerequisiteProto

// optional string key = 1 [json_name = "key", (.help) = "path to config value"];
inline bool OptionPrerequisiteProto::has_key() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void OptionPrerequisiteProto::clear_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& OptionPrerequisiteProto::key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionPrerequisiteProto.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OptionPrerequisiteProto::set_key(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:OptionPrerequisiteProto.key)
}
inline ::std::string* PROTOBUF_NONNULL OptionPrerequisiteProto::mutable_key()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:OptionPrerequisiteProto.key)
  return _s;
}
inline const ::std::string& OptionPrerequisiteProto::_internal_key() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.key_.Get();
}
inline void OptionPrerequisiteProto::_internal_set_key(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.key_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OptionPrerequisiteProto::_internal_mutable_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.key_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OptionPrerequisiteProto::release_key() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionPrerequisiteProto.key)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.key_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.key_.Set("", GetArena());
  }
  return released;
}
inline void OptionPrerequisiteProto::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.key_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:OptionPrerequisiteProto.key)
}

// repeated string value = 2 [json_name = "value", (.help) = "list of required values"];
inline int OptionPrerequisiteProto::_internal_value_size() const {
  return _internal_value().size();
}
inline int OptionPrerequisiteProto::value_size() const {
  return _internal_value_size();
}
inline void OptionPrerequisiteProto::clear_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL OptionPrerequisiteProto::add_value()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_value()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:OptionPrerequisiteProto.value)
  return _s;
}
inline const ::std::string& OptionPrerequisiteProto::value(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionPrerequisiteProto.value)
  return _internal_value().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL OptionPrerequisiteProto::mutable_value(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:OptionPrerequisiteProto.value)
  return _internal_mutable_value()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void OptionPrerequisiteProto::set_value(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_value()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:OptionPrerequisiteProto.value)
}
template <typename Arg_, typename... Args_>
inline void OptionPrerequisiteProto::add_value(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_value(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:OptionPrerequisiteProto.value)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& OptionPrerequisiteProto::value()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:OptionPrerequisiteProto.value)
  return _internal_value();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
OptionPrerequisiteProto::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:OptionPrerequisiteProto.value)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_value();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
OptionPrerequisiteProto::_internal_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
OptionPrerequisiteProto::_internal_mutable_value() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.value_;
}

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

// OptionProto

// optional string name = 1 [json_name = "name", (.help) = "option name"];
inline bool OptionProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void OptionProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& OptionProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OptionProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:OptionProto.name)
}
inline ::std::string* PROTOBUF_NONNULL OptionProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:OptionProto.name)
  return _s;
}
inline const ::std::string& OptionProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void OptionProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OptionProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OptionProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void OptionProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:OptionProto.name)
}

// optional string comment = 2 [json_name = "comment", (.help) = "help text for option"];
inline bool OptionProto::has_comment() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void OptionProto::clear_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& OptionProto::comment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionProto.comment)
  return _internal_comment();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OptionProto::set_comment(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.comment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:OptionProto.comment)
}
inline ::std::string* PROTOBUF_NONNULL OptionProto::mutable_comment()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:OptionProto.comment)
  return _s;
}
inline const ::std::string& OptionProto::_internal_comment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.comment_.Get();
}
inline void OptionProto::_internal_set_comment(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OptionProto::_internal_mutable_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.comment_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OptionProto::release_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionProto.comment)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.comment_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.comment_.Set("", GetArena());
  }
  return released;
}
inline void OptionProto::set_allocated_comment(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.comment_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.comment_.IsDefault()) {
    _impl_.comment_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:OptionProto.comment)
}

// optional string message = 3 [json_name = "message", (.help) = "message to display when option is in use"];
inline bool OptionProto::has_message() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void OptionProto::clear_message() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.message_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& OptionProto::message() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionProto.message)
  return _internal_message();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OptionProto::set_message(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.message_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:OptionProto.message)
}
inline ::std::string* PROTOBUF_NONNULL OptionProto::mutable_message()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:OptionProto.message)
  return _s;
}
inline const ::std::string& OptionProto::_internal_message() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.message_.Get();
}
inline void OptionProto::_internal_set_message(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.message_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OptionProto::_internal_mutable_message() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.message_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OptionProto::release_message() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionProto.message)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.message_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.message_.Set("", GetArena());
  }
  return released;
}
inline void OptionProto::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.message_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:OptionProto.message)
}

// optional bool set_by_default = 6 [default = false, json_name = "setByDefault", (.help) = "this option is applied by default"];
inline bool OptionProto::has_set_by_default() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void OptionProto::clear_set_by_default() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.set_by_default_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline bool OptionProto::set_by_default() const {
  // @@protoc_insertion_point(field_get:OptionProto.set_by_default)
  return _internal_set_by_default();
}
inline void OptionProto::set_set_by_default(bool value) {
  _internal_set_set_by_default(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:OptionProto.set_by_default)
}
inline bool OptionProto::_internal_set_by_default() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.set_by_default_;
}
inline void OptionProto::_internal_set_set_by_default(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.set_by_default_ = value;
}

// repeated .OptionPrerequisiteProto prerequisite = 7 [json_name = "prerequisite", (.help) = "prerequisites for this option"];
inline int OptionProto::_internal_prerequisite_size() const {
  return _internal_prerequisite().size();
}
inline int OptionProto::prerequisite_size() const {
  return _internal_prerequisite_size();
}
inline void OptionProto::clear_prerequisite() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prerequisite_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::OptionPrerequisiteProto& OptionProto::prerequisite(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionProto.prerequisite)
  return _internal_prerequisite().Get(index);
}
inline ::OptionPrerequisiteProto* PROTOBUF_NONNULL OptionProto::mutable_prerequisite(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:OptionProto.prerequisite)
  return _internal_mutable_prerequisite()->Mutable(index);
}
inline ::OptionPrerequisiteProto* PROTOBUF_NONNULL OptionProto::add_prerequisite()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::OptionPrerequisiteProto* _add =
      _internal_mutable_prerequisite()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:OptionProto.prerequisite)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>& OptionProto::prerequisite() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:OptionProto.prerequisite)
  return _internal_prerequisite();
}
inline ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>* PROTOBUF_NONNULL
OptionProto::mutable_prerequisite() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:OptionProto.prerequisite)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_prerequisite();
}
inline const ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>&
OptionProto::_internal_prerequisite() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.prerequisite_;
}
inline ::google::protobuf::RepeatedPtrField<::OptionPrerequisiteProto>* PROTOBUF_NONNULL
OptionProto::_internal_mutable_prerequisite() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.prerequisite_;
}

// optional .ConfigProto config = 4 [json_name = "config", (.help) = "option data"];
inline bool OptionProto::has_config() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.config_ != nullptr);
  return value;
}
inline void OptionProto::clear_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.config_ != nullptr) _impl_.config_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::ConfigProto& OptionProto::_internal_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ConfigProto* p = _impl_.config_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ConfigProto>(&::ConfigProto_globals_);
}
inline const ::ConfigProto& OptionProto::config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionProto.config)
  return _internal_config();
}
inline void OptionProto::unsafe_arena_set_allocated_config(
    ::ConfigProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.config_);
  }
  _impl_.config_ = reinterpret_cast<::ConfigProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OptionProto.config)
}
inline ::ConfigProto* PROTOBUF_NULLABLE OptionProto::release_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::ConfigProto* released = _impl_.config_;
  _impl_.config_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::ConfigProto* PROTOBUF_NULLABLE OptionProto::unsafe_arena_release_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionProto.config)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::ConfigProto* temp = _impl_.config_;
  _impl_.config_ = nullptr;
  return temp;
}
inline ::ConfigProto* PROTOBUF_NONNULL OptionProto::_internal_mutable_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.config_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ConfigProto>(GetArena());
    _impl_.config_ = reinterpret_cast<::ConfigProto*>(p);
  }
  return _impl_.config_;
}
inline ::ConfigProto* PROTOBUF_NONNULL OptionProto::mutable_config()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::ConfigProto* _msg = _internal_mutable_config();
  // @@protoc_insertion_point(field_mutable:OptionProto.config)
  return _msg;
}
inline void OptionProto::set_allocated_config(::ConfigProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.config_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }

  _impl_.config_ = reinterpret_cast<::ConfigProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:OptionProto.config)
}

// repeated .OptionApplicabilityHint applicability = 8 [json_name = "applicability"];
inline int OptionProto::_internal_applicability_size() const {
  return _internal_applicability().size();
}
inline int OptionProto::applicability_size() const {
  return _internal_applicability_size();
}
inline void OptionProto::clear_applicability() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.applicability_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::OptionApplicabilityHint OptionProto::applicability(int index) const {
  // @@protoc_insertion_point(field_get:OptionProto.applicability)
  return static_cast<::OptionApplicabilityHint>(_internal_applicability().Get(index));
}
inline void OptionProto::set_applicability(int index, ::OptionApplicabilityHint value) {

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::OptionApplicabilityHint_internal_data_));
                                          _internal_mutable_applicability()->Set(index, value);
  // @@protoc_insertion_point(field_set:OptionProto.applicability)
}
inline void OptionProto::add_applicability(::OptionApplicabilityHint value) {

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::OptionApplicabilityHint_internal_data_));
                                          ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_applicability()
      ->InternalAddWithArena<const ::google::protobuf::MessageLite*>(
          internal_visibility(), this, value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:OptionProto.applicability)
}
inline const ::google::protobuf::RepeatedField<int>& OptionProto::applicability() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:OptionProto.applicability)
  return _internal_applicability();
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL OptionProto::mutable_applicability()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:OptionProto.applicability)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_applicability();
}
inline const ::google::protobuf::RepeatedField<int>& OptionProto::_internal_applicability()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.applicability_;
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL
OptionProto::_internal_mutable_applicability() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.applicability_;
}

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

// OptionGroupProto

// optional string comment = 1 [json_name = "comment", (.help) = "help text for option group"];
inline bool OptionGroupProto::has_comment() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void OptionGroupProto::clear_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& OptionGroupProto::comment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionGroupProto.comment)
  return _internal_comment();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OptionGroupProto::set_comment(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.comment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:OptionGroupProto.comment)
}
inline ::std::string* PROTOBUF_NONNULL OptionGroupProto::mutable_comment()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:OptionGroupProto.comment)
  return _s;
}
inline const ::std::string& OptionGroupProto::_internal_comment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.comment_.Get();
}
inline void OptionGroupProto::_internal_set_comment(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OptionGroupProto::_internal_mutable_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.comment_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OptionGroupProto::release_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionGroupProto.comment)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.comment_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.comment_.Set("", GetArena());
  }
  return released;
}
inline void OptionGroupProto::set_allocated_comment(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.comment_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.comment_.IsDefault()) {
    _impl_.comment_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:OptionGroupProto.comment)
}

// optional string name = 2 [json_name = "name", (.help) = "option group name"];
inline bool OptionGroupProto::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void OptionGroupProto::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& OptionGroupProto::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionGroupProto.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void OptionGroupProto::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:OptionGroupProto.name)
}
inline ::std::string* PROTOBUF_NONNULL OptionGroupProto::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:OptionGroupProto.name)
  return _s;
}
inline const ::std::string& OptionGroupProto::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void OptionGroupProto::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL OptionGroupProto::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE OptionGroupProto::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:OptionGroupProto.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void OptionGroupProto::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:OptionGroupProto.name)
}

// repeated .OptionProto option = 3 [json_name = "option"];
inline int OptionGroupProto::_internal_option_size() const {
  return _internal_option().size();
}
inline int OptionGroupProto::option_size() const {
  return _internal_option_size();
}
inline void OptionGroupProto::clear_option() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.option_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::OptionProto& OptionGroupProto::option(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:OptionGroupProto.option)
  return _internal_option().Get(index);
}
inline ::OptionProto* PROTOBUF_NONNULL OptionGroupProto::mutable_option(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:OptionGroupProto.option)
  return _internal_mutable_option()->Mutable(index);
}
inline ::OptionProto* PROTOBUF_NONNULL OptionGroupProto::add_option()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::OptionProto* _add =
      _internal_mutable_option()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:OptionGroupProto.option)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::OptionProto>& OptionGroupProto::option() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:OptionGroupProto.option)
  return _internal_option();
}
inline ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL
OptionGroupProto::mutable_option() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:OptionGroupProto.option)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_option();
}
inline const ::google::protobuf::RepeatedPtrField<::OptionProto>&
OptionGroupProto::_internal_option() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.option_;
}
inline ::google::protobuf::RepeatedPtrField<::OptionProto>* PROTOBUF_NONNULL
OptionGroupProto::_internal_mutable_option() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.option_;
}

// repeated .OptionApplicabilityHint applicability = 4 [json_name = "applicability"];
inline int OptionGroupProto::_internal_applicability_size() const {
  return _internal_applicability().size();
}
inline int OptionGroupProto::applicability_size() const {
  return _internal_applicability_size();
}
inline void OptionGroupProto::clear_applicability() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.applicability_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::OptionApplicabilityHint OptionGroupProto::applicability(int index) const {
  // @@protoc_insertion_point(field_get:OptionGroupProto.applicability)
  return static_cast<::OptionApplicabilityHint>(_internal_applicability().Get(index));
}
inline void OptionGroupProto::set_applicability(int index, ::OptionApplicabilityHint value) {

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::OptionApplicabilityHint_internal_data_));
                                          _internal_mutable_applicability()->Set(index, value);
  // @@protoc_insertion_point(field_set:OptionGroupProto.applicability)
}
inline void OptionGroupProto::add_applicability(::OptionApplicabilityHint value) {

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::OptionApplicabilityHint_internal_data_));
                                          ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_applicability()
      ->InternalAddWithArena<const ::google::protobuf::MessageLite*>(
          internal_visibility(), this, value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:OptionGroupProto.applicability)
}
inline const ::google::protobuf::RepeatedField<int>& OptionGroupProto::applicability() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:OptionGroupProto.applicability)
  return _internal_applicability();
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL OptionGroupProto::mutable_applicability()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:OptionGroupProto.applicability)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_applicability();
}
inline const ::google::protobuf::RepeatedField<int>& OptionGroupProto::_internal_applicability()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.applicability_;
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL
OptionGroupProto::_internal_mutable_applicability() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.applicability_;
}

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

// @@protoc_insertion_point(namespace_scope)


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::SupportStatus> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::SupportStatus>() {
  return ::SupportStatus_descriptor();
}
template <>
struct is_proto_enum<::OptionApplicabilityHint> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::OptionApplicabilityHint>() {
  return ::OptionApplicabilityHint_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // lib_2fconfig_2fconfig_2eproto_2epb_2eh
