chromium/out/Default/gen/third_party/perfetto/protos/perfetto/common/descriptor.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protos/perfetto/common/descriptor.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fcommon_2fdescriptor_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fcommon_2fdescriptor_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fperfetto_2fcommon_2fdescriptor_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_protos_2fperfetto_2fcommon_2fdescriptor_2eproto {};
namespace perfetto {
namespace protos {
class DescriptorProto;
struct DescriptorProtoDefaultTypeInternal;
extern DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;
class DescriptorProto_ReservedRange;
struct DescriptorProto_ReservedRangeDefaultTypeInternal;
extern DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;
class EnumDescriptorProto;
struct EnumDescriptorProtoDefaultTypeInternal;
extern EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;
class EnumValueDescriptorProto;
struct EnumValueDescriptorProtoDefaultTypeInternal;
extern EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;
class FieldDescriptorProto;
struct FieldDescriptorProtoDefaultTypeInternal;
extern FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
class FieldOptions;
struct FieldOptionsDefaultTypeInternal;
extern FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
class FileDescriptorProto;
struct FileDescriptorProtoDefaultTypeInternal;
extern FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;
class FileDescriptorSet;
struct FileDescriptorSetDefaultTypeInternal;
extern FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
class OneofDescriptorProto;
struct OneofDescriptorProtoDefaultTypeInternal;
extern OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;
class OneofOptions;
struct OneofOptionsDefaultTypeInternal;
extern OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;
class UninterpretedOption;
struct UninterpretedOptionDefaultTypeInternal;
extern UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;
class UninterpretedOption_NamePart;
struct UninterpretedOption_NamePartDefaultTypeInternal;
extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
}  // namespace protos
}  // namespace perfetto
PROTOBUF_NAMESPACE_OPEN
template<> ::perfetto::protos::DescriptorProto* Arena::CreateMaybeMessage<::perfetto::protos::DescriptorProto>(Arena*);
template<> ::perfetto::protos::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<::perfetto::protos::DescriptorProto_ReservedRange>(Arena*);
template<> ::perfetto::protos::EnumDescriptorProto* Arena::CreateMaybeMessage<::perfetto::protos::EnumDescriptorProto>(Arena*);
template<> ::perfetto::protos::EnumValueDescriptorProto* Arena::CreateMaybeMessage<::perfetto::protos::EnumValueDescriptorProto>(Arena*);
template<> ::perfetto::protos::FieldDescriptorProto* Arena::CreateMaybeMessage<::perfetto::protos::FieldDescriptorProto>(Arena*);
template<> ::perfetto::protos::FieldOptions* Arena::CreateMaybeMessage<::perfetto::protos::FieldOptions>(Arena*);
template<> ::perfetto::protos::FileDescriptorProto* Arena::CreateMaybeMessage<::perfetto::protos::FileDescriptorProto>(Arena*);
template<> ::perfetto::protos::FileDescriptorSet* Arena::CreateMaybeMessage<::perfetto::protos::FileDescriptorSet>(Arena*);
template<> ::perfetto::protos::OneofDescriptorProto* Arena::CreateMaybeMessage<::perfetto::protos::OneofDescriptorProto>(Arena*);
template<> ::perfetto::protos::OneofOptions* Arena::CreateMaybeMessage<::perfetto::protos::OneofOptions>(Arena*);
template<> ::perfetto::protos::UninterpretedOption* Arena::CreateMaybeMessage<::perfetto::protos::UninterpretedOption>(Arena*);
template<> ::perfetto::protos::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<::perfetto::protos::UninterpretedOption_NamePart>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace perfetto {
namespace protos {

enum FieldDescriptorProto_Type : int {};
bool FieldDescriptorProto_Type_IsValid(int value);
constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN =;
constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX =;
constexpr int FieldDescriptorProto_Type_Type_ARRAYSIZE =;

const std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value);
template<typename T>
inline const std::string& FieldDescriptorProto_Type_Name(T enum_t_value) {}
bool FieldDescriptorProto_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Type* value);
enum FieldDescriptorProto_Label : int {};
bool FieldDescriptorProto_Label_IsValid(int value);
constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN =;
constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX =;
constexpr int FieldDescriptorProto_Label_Label_ARRAYSIZE =;

const std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value);
template<typename T>
inline const std::string& FieldDescriptorProto_Label_Name(T enum_t_value) {}
bool FieldDescriptorProto_Label_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Label* value);
// ===================================================================

class FileDescriptorSet final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FileDescriptorSet) */ {};
// -------------------------------------------------------------------

class FileDescriptorProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FileDescriptorProto) */ {};
// -------------------------------------------------------------------

class DescriptorProto_ReservedRange final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.DescriptorProto.ReservedRange) */ {};
// -------------------------------------------------------------------

class DescriptorProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.DescriptorProto) */ {};
// -------------------------------------------------------------------

class UninterpretedOption_NamePart final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.UninterpretedOption.NamePart) */ {};
// -------------------------------------------------------------------

class UninterpretedOption final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.UninterpretedOption) */ {};
// -------------------------------------------------------------------

class FieldOptions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FieldOptions) */ {};
// -------------------------------------------------------------------

class FieldDescriptorProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FieldDescriptorProto) */ {};
// -------------------------------------------------------------------

class OneofDescriptorProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.OneofDescriptorProto) */ {};
// -------------------------------------------------------------------

class EnumDescriptorProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.EnumDescriptorProto) */ {};
// -------------------------------------------------------------------

class EnumValueDescriptorProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.EnumValueDescriptorProto) */ {};
// -------------------------------------------------------------------

class OneofOptions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.OneofOptions) */ {};
// ===================================================================


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

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

// repeated .perfetto.protos.FileDescriptorProto file = 1;
inline int FileDescriptorSet::_internal_file_size() const {}
inline int FileDescriptorSet::file_size() const {}
inline void FileDescriptorSet::clear_file() {}
inline ::perfetto::protos::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FileDescriptorProto >*
FileDescriptorSet::mutable_file() {}
inline const ::perfetto::protos::FileDescriptorProto& FileDescriptorSet::_internal_file(int index) const {}
inline const ::perfetto::protos::FileDescriptorProto& FileDescriptorSet::file(int index) const {}
inline ::perfetto::protos::FileDescriptorProto* FileDescriptorSet::_internal_add_file() {}
inline ::perfetto::protos::FileDescriptorProto* FileDescriptorSet::add_file() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FileDescriptorProto >&
FileDescriptorSet::file() const {}

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

// FileDescriptorProto

// optional string name = 1;
inline bool FileDescriptorProto::_internal_has_name() const {}
inline bool FileDescriptorProto::has_name() const {}
inline void FileDescriptorProto::clear_name() {}
inline const std::string& FileDescriptorProto::name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FileDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* FileDescriptorProto::mutable_name() {}
inline const std::string& FileDescriptorProto::_internal_name() const {}
inline void FileDescriptorProto::_internal_set_name(const std::string& value) {}
inline std::string* FileDescriptorProto::_internal_mutable_name() {}
inline std::string* FileDescriptorProto::release_name() {}
inline void FileDescriptorProto::set_allocated_name(std::string* name) {}

// optional string package = 2;
inline bool FileDescriptorProto::_internal_has_package() const {}
inline bool FileDescriptorProto::has_package() const {}
inline void FileDescriptorProto::clear_package() {}
inline const std::string& FileDescriptorProto::package() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FileDescriptorProto::set_package(ArgT0&& arg0, ArgT... args) {}
inline std::string* FileDescriptorProto::mutable_package() {}
inline const std::string& FileDescriptorProto::_internal_package() const {}
inline void FileDescriptorProto::_internal_set_package(const std::string& value) {}
inline std::string* FileDescriptorProto::_internal_mutable_package() {}
inline std::string* FileDescriptorProto::release_package() {}
inline void FileDescriptorProto::set_allocated_package(std::string* package) {}

// repeated string dependency = 3;
inline int FileDescriptorProto::_internal_dependency_size() const {}
inline int FileDescriptorProto::dependency_size() const {}
inline void FileDescriptorProto::clear_dependency() {}
inline std::string* FileDescriptorProto::add_dependency() {}
inline const std::string& FileDescriptorProto::_internal_dependency(int index) const {}
inline const std::string& FileDescriptorProto::dependency(int index) const {}
inline std::string* FileDescriptorProto::mutable_dependency(int index) {}
inline void FileDescriptorProto::set_dependency(int index, const std::string& value) {}
inline void FileDescriptorProto::set_dependency(int index, std::string&& value) {}
inline void FileDescriptorProto::set_dependency(int index, const char* value) {}
inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) {}
inline std::string* FileDescriptorProto::_internal_add_dependency() {}
inline void FileDescriptorProto::add_dependency(const std::string& value) {}
inline void FileDescriptorProto::add_dependency(std::string&& value) {}
inline void FileDescriptorProto::add_dependency(const char* value) {}
inline void FileDescriptorProto::add_dependency(const char* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FileDescriptorProto::dependency() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FileDescriptorProto::mutable_dependency() {}

// repeated int32 public_dependency = 10;
inline int FileDescriptorProto::_internal_public_dependency_size() const {}
inline int FileDescriptorProto::public_dependency_size() const {}
inline void FileDescriptorProto::clear_public_dependency() {}
inline int32_t FileDescriptorProto::_internal_public_dependency(int index) const {}
inline int32_t FileDescriptorProto::public_dependency(int index) const {}
inline void FileDescriptorProto::set_public_dependency(int index, int32_t value) {}
inline void FileDescriptorProto::_internal_add_public_dependency(int32_t value) {}
inline void FileDescriptorProto::add_public_dependency(int32_t value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
FileDescriptorProto::_internal_public_dependency() const {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
FileDescriptorProto::public_dependency() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
FileDescriptorProto::_internal_mutable_public_dependency() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
FileDescriptorProto::mutable_public_dependency() {}

// repeated int32 weak_dependency = 11;
inline int FileDescriptorProto::_internal_weak_dependency_size() const {}
inline int FileDescriptorProto::weak_dependency_size() const {}
inline void FileDescriptorProto::clear_weak_dependency() {}
inline int32_t FileDescriptorProto::_internal_weak_dependency(int index) const {}
inline int32_t FileDescriptorProto::weak_dependency(int index) const {}
inline void FileDescriptorProto::set_weak_dependency(int index, int32_t value) {}
inline void FileDescriptorProto::_internal_add_weak_dependency(int32_t value) {}
inline void FileDescriptorProto::add_weak_dependency(int32_t value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
FileDescriptorProto::_internal_weak_dependency() const {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
FileDescriptorProto::weak_dependency() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
FileDescriptorProto::_internal_mutable_weak_dependency() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
FileDescriptorProto::mutable_weak_dependency() {}

// repeated .perfetto.protos.DescriptorProto message_type = 4;
inline int FileDescriptorProto::_internal_message_type_size() const {}
inline int FileDescriptorProto::message_type_size() const {}
inline void FileDescriptorProto::clear_message_type() {}
inline ::perfetto::protos::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::DescriptorProto >*
FileDescriptorProto::mutable_message_type() {}
inline const ::perfetto::protos::DescriptorProto& FileDescriptorProto::_internal_message_type(int index) const {}
inline const ::perfetto::protos::DescriptorProto& FileDescriptorProto::message_type(int index) const {}
inline ::perfetto::protos::DescriptorProto* FileDescriptorProto::_internal_add_message_type() {}
inline ::perfetto::protos::DescriptorProto* FileDescriptorProto::add_message_type() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::DescriptorProto >&
FileDescriptorProto::message_type() const {}

// repeated .perfetto.protos.EnumDescriptorProto enum_type = 5;
inline int FileDescriptorProto::_internal_enum_type_size() const {}
inline int FileDescriptorProto::enum_type_size() const {}
inline void FileDescriptorProto::clear_enum_type() {}
inline ::perfetto::protos::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::EnumDescriptorProto >*
FileDescriptorProto::mutable_enum_type() {}
inline const ::perfetto::protos::EnumDescriptorProto& FileDescriptorProto::_internal_enum_type(int index) const {}
inline const ::perfetto::protos::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const {}
inline ::perfetto::protos::EnumDescriptorProto* FileDescriptorProto::_internal_add_enum_type() {}
inline ::perfetto::protos::EnumDescriptorProto* FileDescriptorProto::add_enum_type() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::EnumDescriptorProto >&
FileDescriptorProto::enum_type() const {}

// repeated .perfetto.protos.FieldDescriptorProto extension = 7;
inline int FileDescriptorProto::_internal_extension_size() const {}
inline int FileDescriptorProto::extension_size() const {}
inline void FileDescriptorProto::clear_extension() {}
inline ::perfetto::protos::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FieldDescriptorProto >*
FileDescriptorProto::mutable_extension() {}
inline const ::perfetto::protos::FieldDescriptorProto& FileDescriptorProto::_internal_extension(int index) const {}
inline const ::perfetto::protos::FieldDescriptorProto& FileDescriptorProto::extension(int index) const {}
inline ::perfetto::protos::FieldDescriptorProto* FileDescriptorProto::_internal_add_extension() {}
inline ::perfetto::protos::FieldDescriptorProto* FileDescriptorProto::add_extension() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FieldDescriptorProto >&
FileDescriptorProto::extension() const {}

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

// DescriptorProto_ReservedRange

// optional int32 start = 1;
inline bool DescriptorProto_ReservedRange::_internal_has_start() const {}
inline bool DescriptorProto_ReservedRange::has_start() const {}
inline void DescriptorProto_ReservedRange::clear_start() {}
inline int32_t DescriptorProto_ReservedRange::_internal_start() const {}
inline int32_t DescriptorProto_ReservedRange::start() const {}
inline void DescriptorProto_ReservedRange::_internal_set_start(int32_t value) {}
inline void DescriptorProto_ReservedRange::set_start(int32_t value) {}

// optional int32 end = 2;
inline bool DescriptorProto_ReservedRange::_internal_has_end() const {}
inline bool DescriptorProto_ReservedRange::has_end() const {}
inline void DescriptorProto_ReservedRange::clear_end() {}
inline int32_t DescriptorProto_ReservedRange::_internal_end() const {}
inline int32_t DescriptorProto_ReservedRange::end() const {}
inline void DescriptorProto_ReservedRange::_internal_set_end(int32_t value) {}
inline void DescriptorProto_ReservedRange::set_end(int32_t value) {}

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

// DescriptorProto

// optional string name = 1;
inline bool DescriptorProto::_internal_has_name() const {}
inline bool DescriptorProto::has_name() const {}
inline void DescriptorProto::clear_name() {}
inline const std::string& DescriptorProto::name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* DescriptorProto::mutable_name() {}
inline const std::string& DescriptorProto::_internal_name() const {}
inline void DescriptorProto::_internal_set_name(const std::string& value) {}
inline std::string* DescriptorProto::_internal_mutable_name() {}
inline std::string* DescriptorProto::release_name() {}
inline void DescriptorProto::set_allocated_name(std::string* name) {}

// repeated .perfetto.protos.FieldDescriptorProto field = 2;
inline int DescriptorProto::_internal_field_size() const {}
inline int DescriptorProto::field_size() const {}
inline void DescriptorProto::clear_field() {}
inline ::perfetto::protos::FieldDescriptorProto* DescriptorProto::mutable_field(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FieldDescriptorProto >*
DescriptorProto::mutable_field() {}
inline const ::perfetto::protos::FieldDescriptorProto& DescriptorProto::_internal_field(int index) const {}
inline const ::perfetto::protos::FieldDescriptorProto& DescriptorProto::field(int index) const {}
inline ::perfetto::protos::FieldDescriptorProto* DescriptorProto::_internal_add_field() {}
inline ::perfetto::protos::FieldDescriptorProto* DescriptorProto::add_field() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FieldDescriptorProto >&
DescriptorProto::field() const {}

// repeated .perfetto.protos.FieldDescriptorProto extension = 6;
inline int DescriptorProto::_internal_extension_size() const {}
inline int DescriptorProto::extension_size() const {}
inline void DescriptorProto::clear_extension() {}
inline ::perfetto::protos::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FieldDescriptorProto >*
DescriptorProto::mutable_extension() {}
inline const ::perfetto::protos::FieldDescriptorProto& DescriptorProto::_internal_extension(int index) const {}
inline const ::perfetto::protos::FieldDescriptorProto& DescriptorProto::extension(int index) const {}
inline ::perfetto::protos::FieldDescriptorProto* DescriptorProto::_internal_add_extension() {}
inline ::perfetto::protos::FieldDescriptorProto* DescriptorProto::add_extension() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FieldDescriptorProto >&
DescriptorProto::extension() const {}

// repeated .perfetto.protos.DescriptorProto nested_type = 3;
inline int DescriptorProto::_internal_nested_type_size() const {}
inline int DescriptorProto::nested_type_size() const {}
inline void DescriptorProto::clear_nested_type() {}
inline ::perfetto::protos::DescriptorProto* DescriptorProto::mutable_nested_type(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::DescriptorProto >*
DescriptorProto::mutable_nested_type() {}
inline const ::perfetto::protos::DescriptorProto& DescriptorProto::_internal_nested_type(int index) const {}
inline const ::perfetto::protos::DescriptorProto& DescriptorProto::nested_type(int index) const {}
inline ::perfetto::protos::DescriptorProto* DescriptorProto::_internal_add_nested_type() {}
inline ::perfetto::protos::DescriptorProto* DescriptorProto::add_nested_type() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::DescriptorProto >&
DescriptorProto::nested_type() const {}

// repeated .perfetto.protos.EnumDescriptorProto enum_type = 4;
inline int DescriptorProto::_internal_enum_type_size() const {}
inline int DescriptorProto::enum_type_size() const {}
inline void DescriptorProto::clear_enum_type() {}
inline ::perfetto::protos::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::EnumDescriptorProto >*
DescriptorProto::mutable_enum_type() {}
inline const ::perfetto::protos::EnumDescriptorProto& DescriptorProto::_internal_enum_type(int index) const {}
inline const ::perfetto::protos::EnumDescriptorProto& DescriptorProto::enum_type(int index) const {}
inline ::perfetto::protos::EnumDescriptorProto* DescriptorProto::_internal_add_enum_type() {}
inline ::perfetto::protos::EnumDescriptorProto* DescriptorProto::add_enum_type() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::EnumDescriptorProto >&
DescriptorProto::enum_type() const {}

// repeated .perfetto.protos.OneofDescriptorProto oneof_decl = 8;
inline int DescriptorProto::_internal_oneof_decl_size() const {}
inline int DescriptorProto::oneof_decl_size() const {}
inline void DescriptorProto::clear_oneof_decl() {}
inline ::perfetto::protos::OneofDescriptorProto* DescriptorProto::mutable_oneof_decl(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::OneofDescriptorProto >*
DescriptorProto::mutable_oneof_decl() {}
inline const ::perfetto::protos::OneofDescriptorProto& DescriptorProto::_internal_oneof_decl(int index) const {}
inline const ::perfetto::protos::OneofDescriptorProto& DescriptorProto::oneof_decl(int index) const {}
inline ::perfetto::protos::OneofDescriptorProto* DescriptorProto::_internal_add_oneof_decl() {}
inline ::perfetto::protos::OneofDescriptorProto* DescriptorProto::add_oneof_decl() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::OneofDescriptorProto >&
DescriptorProto::oneof_decl() const {}

// repeated .perfetto.protos.DescriptorProto.ReservedRange reserved_range = 9;
inline int DescriptorProto::_internal_reserved_range_size() const {}
inline int DescriptorProto::reserved_range_size() const {}
inline void DescriptorProto::clear_reserved_range() {}
inline ::perfetto::protos::DescriptorProto_ReservedRange* DescriptorProto::mutable_reserved_range(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::DescriptorProto_ReservedRange >*
DescriptorProto::mutable_reserved_range() {}
inline const ::perfetto::protos::DescriptorProto_ReservedRange& DescriptorProto::_internal_reserved_range(int index) const {}
inline const ::perfetto::protos::DescriptorProto_ReservedRange& DescriptorProto::reserved_range(int index) const {}
inline ::perfetto::protos::DescriptorProto_ReservedRange* DescriptorProto::_internal_add_reserved_range() {}
inline ::perfetto::protos::DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::DescriptorProto_ReservedRange >&
DescriptorProto::reserved_range() const {}

// repeated string reserved_name = 10;
inline int DescriptorProto::_internal_reserved_name_size() const {}
inline int DescriptorProto::reserved_name_size() const {}
inline void DescriptorProto::clear_reserved_name() {}
inline std::string* DescriptorProto::add_reserved_name() {}
inline const std::string& DescriptorProto::_internal_reserved_name(int index) const {}
inline const std::string& DescriptorProto::reserved_name(int index) const {}
inline std::string* DescriptorProto::mutable_reserved_name(int index) {}
inline void DescriptorProto::set_reserved_name(int index, const std::string& value) {}
inline void DescriptorProto::set_reserved_name(int index, std::string&& value) {}
inline void DescriptorProto::set_reserved_name(int index, const char* value) {}
inline void DescriptorProto::set_reserved_name(int index, const char* value, size_t size) {}
inline std::string* DescriptorProto::_internal_add_reserved_name() {}
inline void DescriptorProto::add_reserved_name(const std::string& value) {}
inline void DescriptorProto::add_reserved_name(std::string&& value) {}
inline void DescriptorProto::add_reserved_name(const char* value) {}
inline void DescriptorProto::add_reserved_name(const char* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DescriptorProto::reserved_name() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DescriptorProto::mutable_reserved_name() {}

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

// UninterpretedOption_NamePart

// optional string name_part = 1;
inline bool UninterpretedOption_NamePart::_internal_has_name_part() const {}
inline bool UninterpretedOption_NamePart::has_name_part() const {}
inline void UninterpretedOption_NamePart::clear_name_part() {}
inline const std::string& UninterpretedOption_NamePart::name_part() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UninterpretedOption_NamePart::set_name_part(ArgT0&& arg0, ArgT... args) {}
inline std::string* UninterpretedOption_NamePart::mutable_name_part() {}
inline const std::string& UninterpretedOption_NamePart::_internal_name_part() const {}
inline void UninterpretedOption_NamePart::_internal_set_name_part(const std::string& value) {}
inline std::string* UninterpretedOption_NamePart::_internal_mutable_name_part() {}
inline std::string* UninterpretedOption_NamePart::release_name_part() {}
inline void UninterpretedOption_NamePart::set_allocated_name_part(std::string* name_part) {}

// optional bool is_extension = 2;
inline bool UninterpretedOption_NamePart::_internal_has_is_extension() const {}
inline bool UninterpretedOption_NamePart::has_is_extension() const {}
inline void UninterpretedOption_NamePart::clear_is_extension() {}
inline bool UninterpretedOption_NamePart::_internal_is_extension() const {}
inline bool UninterpretedOption_NamePart::is_extension() const {}
inline void UninterpretedOption_NamePart::_internal_set_is_extension(bool value) {}
inline void UninterpretedOption_NamePart::set_is_extension(bool value) {}

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

// UninterpretedOption

// repeated .perfetto.protos.UninterpretedOption.NamePart name = 2;
inline int UninterpretedOption::_internal_name_size() const {}
inline int UninterpretedOption::name_size() const {}
inline void UninterpretedOption::clear_name() {}
inline ::perfetto::protos::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::UninterpretedOption_NamePart >*
UninterpretedOption::mutable_name() {}
inline const ::perfetto::protos::UninterpretedOption_NamePart& UninterpretedOption::_internal_name(int index) const {}
inline const ::perfetto::protos::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const {}
inline ::perfetto::protos::UninterpretedOption_NamePart* UninterpretedOption::_internal_add_name() {}
inline ::perfetto::protos::UninterpretedOption_NamePart* UninterpretedOption::add_name() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::UninterpretedOption_NamePart >&
UninterpretedOption::name() const {}

// optional string identifier_value = 3;
inline bool UninterpretedOption::_internal_has_identifier_value() const {}
inline bool UninterpretedOption::has_identifier_value() const {}
inline void UninterpretedOption::clear_identifier_value() {}
inline const std::string& UninterpretedOption::identifier_value() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UninterpretedOption::set_identifier_value(ArgT0&& arg0, ArgT... args) {}
inline std::string* UninterpretedOption::mutable_identifier_value() {}
inline const std::string& UninterpretedOption::_internal_identifier_value() const {}
inline void UninterpretedOption::_internal_set_identifier_value(const std::string& value) {}
inline std::string* UninterpretedOption::_internal_mutable_identifier_value() {}
inline std::string* UninterpretedOption::release_identifier_value() {}
inline void UninterpretedOption::set_allocated_identifier_value(std::string* identifier_value) {}

// optional uint64 positive_int_value = 4;
inline bool UninterpretedOption::_internal_has_positive_int_value() const {}
inline bool UninterpretedOption::has_positive_int_value() const {}
inline void UninterpretedOption::clear_positive_int_value() {}
inline uint64_t UninterpretedOption::_internal_positive_int_value() const {}
inline uint64_t UninterpretedOption::positive_int_value() const {}
inline void UninterpretedOption::_internal_set_positive_int_value(uint64_t value) {}
inline void UninterpretedOption::set_positive_int_value(uint64_t value) {}

// optional int64 negative_int_value = 5;
inline bool UninterpretedOption::_internal_has_negative_int_value() const {}
inline bool UninterpretedOption::has_negative_int_value() const {}
inline void UninterpretedOption::clear_negative_int_value() {}
inline int64_t UninterpretedOption::_internal_negative_int_value() const {}
inline int64_t UninterpretedOption::negative_int_value() const {}
inline void UninterpretedOption::_internal_set_negative_int_value(int64_t value) {}
inline void UninterpretedOption::set_negative_int_value(int64_t value) {}

// optional double double_value = 6;
inline bool UninterpretedOption::_internal_has_double_value() const {}
inline bool UninterpretedOption::has_double_value() const {}
inline void UninterpretedOption::clear_double_value() {}
inline double UninterpretedOption::_internal_double_value() const {}
inline double UninterpretedOption::double_value() const {}
inline void UninterpretedOption::_internal_set_double_value(double value) {}
inline void UninterpretedOption::set_double_value(double value) {}

// optional bytes string_value = 7;
inline bool UninterpretedOption::_internal_has_string_value() const {}
inline bool UninterpretedOption::has_string_value() const {}
inline void UninterpretedOption::clear_string_value() {}
inline const std::string& UninterpretedOption::string_value() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UninterpretedOption::set_string_value(ArgT0&& arg0, ArgT... args) {}
inline std::string* UninterpretedOption::mutable_string_value() {}
inline const std::string& UninterpretedOption::_internal_string_value() const {}
inline void UninterpretedOption::_internal_set_string_value(const std::string& value) {}
inline std::string* UninterpretedOption::_internal_mutable_string_value() {}
inline std::string* UninterpretedOption::release_string_value() {}
inline void UninterpretedOption::set_allocated_string_value(std::string* string_value) {}

// optional string aggregate_value = 8;
inline bool UninterpretedOption::_internal_has_aggregate_value() const {}
inline bool UninterpretedOption::has_aggregate_value() const {}
inline void UninterpretedOption::clear_aggregate_value() {}
inline const std::string& UninterpretedOption::aggregate_value() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UninterpretedOption::set_aggregate_value(ArgT0&& arg0, ArgT... args) {}
inline std::string* UninterpretedOption::mutable_aggregate_value() {}
inline const std::string& UninterpretedOption::_internal_aggregate_value() const {}
inline void UninterpretedOption::_internal_set_aggregate_value(const std::string& value) {}
inline std::string* UninterpretedOption::_internal_mutable_aggregate_value() {}
inline std::string* UninterpretedOption::release_aggregate_value() {}
inline void UninterpretedOption::set_allocated_aggregate_value(std::string* aggregate_value) {}

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

// FieldOptions

// optional bool packed = 2;
inline bool FieldOptions::_internal_has_packed() const {}
inline bool FieldOptions::has_packed() const {}
inline void FieldOptions::clear_packed() {}
inline bool FieldOptions::_internal_packed() const {}
inline bool FieldOptions::packed() const {}
inline void FieldOptions::_internal_set_packed(bool value) {}
inline void FieldOptions::set_packed(bool value) {}

// repeated .perfetto.protos.UninterpretedOption uninterpreted_option = 999;
inline int FieldOptions::_internal_uninterpreted_option_size() const {}
inline int FieldOptions::uninterpreted_option_size() const {}
inline void FieldOptions::clear_uninterpreted_option() {}
inline ::perfetto::protos::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::UninterpretedOption >*
FieldOptions::mutable_uninterpreted_option() {}
inline const ::perfetto::protos::UninterpretedOption& FieldOptions::_internal_uninterpreted_option(int index) const {}
inline const ::perfetto::protos::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const {}
inline ::perfetto::protos::UninterpretedOption* FieldOptions::_internal_add_uninterpreted_option() {}
inline ::perfetto::protos::UninterpretedOption* FieldOptions::add_uninterpreted_option() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::UninterpretedOption >&
FieldOptions::uninterpreted_option() const {}

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

// FieldDescriptorProto

// optional string name = 1;
inline bool FieldDescriptorProto::_internal_has_name() const {}
inline bool FieldDescriptorProto::has_name() const {}
inline void FieldDescriptorProto::clear_name() {}
inline const std::string& FieldDescriptorProto::name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* FieldDescriptorProto::mutable_name() {}
inline const std::string& FieldDescriptorProto::_internal_name() const {}
inline void FieldDescriptorProto::_internal_set_name(const std::string& value) {}
inline std::string* FieldDescriptorProto::_internal_mutable_name() {}
inline std::string* FieldDescriptorProto::release_name() {}
inline void FieldDescriptorProto::set_allocated_name(std::string* name) {}

// optional int32 number = 3;
inline bool FieldDescriptorProto::_internal_has_number() const {}
inline bool FieldDescriptorProto::has_number() const {}
inline void FieldDescriptorProto::clear_number() {}
inline int32_t FieldDescriptorProto::_internal_number() const {}
inline int32_t FieldDescriptorProto::number() const {}
inline void FieldDescriptorProto::_internal_set_number(int32_t value) {}
inline void FieldDescriptorProto::set_number(int32_t value) {}

// optional .perfetto.protos.FieldDescriptorProto.Label label = 4;
inline bool FieldDescriptorProto::_internal_has_label() const {}
inline bool FieldDescriptorProto::has_label() const {}
inline void FieldDescriptorProto::clear_label() {}
inline ::perfetto::protos::FieldDescriptorProto_Label FieldDescriptorProto::_internal_label() const {}
inline ::perfetto::protos::FieldDescriptorProto_Label FieldDescriptorProto::label() const {}
inline void FieldDescriptorProto::_internal_set_label(::perfetto::protos::FieldDescriptorProto_Label value) {}
inline void FieldDescriptorProto::set_label(::perfetto::protos::FieldDescriptorProto_Label value) {}

// optional .perfetto.protos.FieldDescriptorProto.Type type = 5;
inline bool FieldDescriptorProto::_internal_has_type() const {}
inline bool FieldDescriptorProto::has_type() const {}
inline void FieldDescriptorProto::clear_type() {}
inline ::perfetto::protos::FieldDescriptorProto_Type FieldDescriptorProto::_internal_type() const {}
inline ::perfetto::protos::FieldDescriptorProto_Type FieldDescriptorProto::type() const {}
inline void FieldDescriptorProto::_internal_set_type(::perfetto::protos::FieldDescriptorProto_Type value) {}
inline void FieldDescriptorProto::set_type(::perfetto::protos::FieldDescriptorProto_Type value) {}

// optional string type_name = 6;
inline bool FieldDescriptorProto::_internal_has_type_name() const {}
inline bool FieldDescriptorProto::has_type_name() const {}
inline void FieldDescriptorProto::clear_type_name() {}
inline const std::string& FieldDescriptorProto::type_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldDescriptorProto::set_type_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* FieldDescriptorProto::mutable_type_name() {}
inline const std::string& FieldDescriptorProto::_internal_type_name() const {}
inline void FieldDescriptorProto::_internal_set_type_name(const std::string& value) {}
inline std::string* FieldDescriptorProto::_internal_mutable_type_name() {}
inline std::string* FieldDescriptorProto::release_type_name() {}
inline void FieldDescriptorProto::set_allocated_type_name(std::string* type_name) {}

// optional string extendee = 2;
inline bool FieldDescriptorProto::_internal_has_extendee() const {}
inline bool FieldDescriptorProto::has_extendee() const {}
inline void FieldDescriptorProto::clear_extendee() {}
inline const std::string& FieldDescriptorProto::extendee() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldDescriptorProto::set_extendee(ArgT0&& arg0, ArgT... args) {}
inline std::string* FieldDescriptorProto::mutable_extendee() {}
inline const std::string& FieldDescriptorProto::_internal_extendee() const {}
inline void FieldDescriptorProto::_internal_set_extendee(const std::string& value) {}
inline std::string* FieldDescriptorProto::_internal_mutable_extendee() {}
inline std::string* FieldDescriptorProto::release_extendee() {}
inline void FieldDescriptorProto::set_allocated_extendee(std::string* extendee) {}

// optional string default_value = 7;
inline bool FieldDescriptorProto::_internal_has_default_value() const {}
inline bool FieldDescriptorProto::has_default_value() const {}
inline void FieldDescriptorProto::clear_default_value() {}
inline const std::string& FieldDescriptorProto::default_value() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldDescriptorProto::set_default_value(ArgT0&& arg0, ArgT... args) {}
inline std::string* FieldDescriptorProto::mutable_default_value() {}
inline const std::string& FieldDescriptorProto::_internal_default_value() const {}
inline void FieldDescriptorProto::_internal_set_default_value(const std::string& value) {}
inline std::string* FieldDescriptorProto::_internal_mutable_default_value() {}
inline std::string* FieldDescriptorProto::release_default_value() {}
inline void FieldDescriptorProto::set_allocated_default_value(std::string* default_value) {}

// optional .perfetto.protos.FieldOptions options = 8;
inline bool FieldDescriptorProto::_internal_has_options() const {}
inline bool FieldDescriptorProto::has_options() const {}
inline void FieldDescriptorProto::clear_options() {}
inline const ::perfetto::protos::FieldOptions& FieldDescriptorProto::_internal_options() const {}
inline const ::perfetto::protos::FieldOptions& FieldDescriptorProto::options() const {}
inline void FieldDescriptorProto::unsafe_arena_set_allocated_options(
    ::perfetto::protos::FieldOptions* options) {}
inline ::perfetto::protos::FieldOptions* FieldDescriptorProto::release_options() {}
inline ::perfetto::protos::FieldOptions* FieldDescriptorProto::unsafe_arena_release_options() {}
inline ::perfetto::protos::FieldOptions* FieldDescriptorProto::_internal_mutable_options() {}
inline ::perfetto::protos::FieldOptions* FieldDescriptorProto::mutable_options() {}
inline void FieldDescriptorProto::set_allocated_options(::perfetto::protos::FieldOptions* options) {}

// optional int32 oneof_index = 9;
inline bool FieldDescriptorProto::_internal_has_oneof_index() const {}
inline bool FieldDescriptorProto::has_oneof_index() const {}
inline void FieldDescriptorProto::clear_oneof_index() {}
inline int32_t FieldDescriptorProto::_internal_oneof_index() const {}
inline int32_t FieldDescriptorProto::oneof_index() const {}
inline void FieldDescriptorProto::_internal_set_oneof_index(int32_t value) {}
inline void FieldDescriptorProto::set_oneof_index(int32_t value) {}

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

// OneofDescriptorProto

// optional string name = 1;
inline bool OneofDescriptorProto::_internal_has_name() const {}
inline bool OneofDescriptorProto::has_name() const {}
inline void OneofDescriptorProto::clear_name() {}
inline const std::string& OneofDescriptorProto::name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OneofDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* OneofDescriptorProto::mutable_name() {}
inline const std::string& OneofDescriptorProto::_internal_name() const {}
inline void OneofDescriptorProto::_internal_set_name(const std::string& value) {}
inline std::string* OneofDescriptorProto::_internal_mutable_name() {}
inline std::string* OneofDescriptorProto::release_name() {}
inline void OneofDescriptorProto::set_allocated_name(std::string* name) {}

// optional .perfetto.protos.OneofOptions options = 2;
inline bool OneofDescriptorProto::_internal_has_options() const {}
inline bool OneofDescriptorProto::has_options() const {}
inline void OneofDescriptorProto::clear_options() {}
inline const ::perfetto::protos::OneofOptions& OneofDescriptorProto::_internal_options() const {}
inline const ::perfetto::protos::OneofOptions& OneofDescriptorProto::options() const {}
inline void OneofDescriptorProto::unsafe_arena_set_allocated_options(
    ::perfetto::protos::OneofOptions* options) {}
inline ::perfetto::protos::OneofOptions* OneofDescriptorProto::release_options() {}
inline ::perfetto::protos::OneofOptions* OneofDescriptorProto::unsafe_arena_release_options() {}
inline ::perfetto::protos::OneofOptions* OneofDescriptorProto::_internal_mutable_options() {}
inline ::perfetto::protos::OneofOptions* OneofDescriptorProto::mutable_options() {}
inline void OneofDescriptorProto::set_allocated_options(::perfetto::protos::OneofOptions* options) {}

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

// EnumDescriptorProto

// optional string name = 1;
inline bool EnumDescriptorProto::_internal_has_name() const {}
inline bool EnumDescriptorProto::has_name() const {}
inline void EnumDescriptorProto::clear_name() {}
inline const std::string& EnumDescriptorProto::name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EnumDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* EnumDescriptorProto::mutable_name() {}
inline const std::string& EnumDescriptorProto::_internal_name() const {}
inline void EnumDescriptorProto::_internal_set_name(const std::string& value) {}
inline std::string* EnumDescriptorProto::_internal_mutable_name() {}
inline std::string* EnumDescriptorProto::release_name() {}
inline void EnumDescriptorProto::set_allocated_name(std::string* name) {}

// repeated .perfetto.protos.EnumValueDescriptorProto value = 2;
inline int EnumDescriptorProto::_internal_value_size() const {}
inline int EnumDescriptorProto::value_size() const {}
inline void EnumDescriptorProto::clear_value() {}
inline ::perfetto::protos::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::EnumValueDescriptorProto >*
EnumDescriptorProto::mutable_value() {}
inline const ::perfetto::protos::EnumValueDescriptorProto& EnumDescriptorProto::_internal_value(int index) const {}
inline const ::perfetto::protos::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const {}
inline ::perfetto::protos::EnumValueDescriptorProto* EnumDescriptorProto::_internal_add_value() {}
inline ::perfetto::protos::EnumValueDescriptorProto* EnumDescriptorProto::add_value() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::EnumValueDescriptorProto >&
EnumDescriptorProto::value() const {}

// repeated string reserved_name = 5;
inline int EnumDescriptorProto::_internal_reserved_name_size() const {}
inline int EnumDescriptorProto::reserved_name_size() const {}
inline void EnumDescriptorProto::clear_reserved_name() {}
inline std::string* EnumDescriptorProto::add_reserved_name() {}
inline const std::string& EnumDescriptorProto::_internal_reserved_name(int index) const {}
inline const std::string& EnumDescriptorProto::reserved_name(int index) const {}
inline std::string* EnumDescriptorProto::mutable_reserved_name(int index) {}
inline void EnumDescriptorProto::set_reserved_name(int index, const std::string& value) {}
inline void EnumDescriptorProto::set_reserved_name(int index, std::string&& value) {}
inline void EnumDescriptorProto::set_reserved_name(int index, const char* value) {}
inline void EnumDescriptorProto::set_reserved_name(int index, const char* value, size_t size) {}
inline std::string* EnumDescriptorProto::_internal_add_reserved_name() {}
inline void EnumDescriptorProto::add_reserved_name(const std::string& value) {}
inline void EnumDescriptorProto::add_reserved_name(std::string&& value) {}
inline void EnumDescriptorProto::add_reserved_name(const char* value) {}
inline void EnumDescriptorProto::add_reserved_name(const char* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
EnumDescriptorProto::reserved_name() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
EnumDescriptorProto::mutable_reserved_name() {}

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

// EnumValueDescriptorProto

// optional string name = 1;
inline bool EnumValueDescriptorProto::_internal_has_name() const {}
inline bool EnumValueDescriptorProto::has_name() const {}
inline void EnumValueDescriptorProto::clear_name() {}
inline const std::string& EnumValueDescriptorProto::name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EnumValueDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* EnumValueDescriptorProto::mutable_name() {}
inline const std::string& EnumValueDescriptorProto::_internal_name() const {}
inline void EnumValueDescriptorProto::_internal_set_name(const std::string& value) {}
inline std::string* EnumValueDescriptorProto::_internal_mutable_name() {}
inline std::string* EnumValueDescriptorProto::release_name() {}
inline void EnumValueDescriptorProto::set_allocated_name(std::string* name) {}

// optional int32 number = 2;
inline bool EnumValueDescriptorProto::_internal_has_number() const {}
inline bool EnumValueDescriptorProto::has_number() const {}
inline void EnumValueDescriptorProto::clear_number() {}
inline int32_t EnumValueDescriptorProto::_internal_number() const {}
inline int32_t EnumValueDescriptorProto::number() const {}
inline void EnumValueDescriptorProto::_internal_set_number(int32_t value) {}
inline void EnumValueDescriptorProto::set_number(int32_t value) {}

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

// OneofOptions

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace perfetto

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::perfetto::protos::FieldDescriptorProto_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::FieldDescriptorProto_Label> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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