// Generated by the protocol buffer compiler.  DO NOT EDIT!

// NO CHECKED-IN PROTOBUF GENCODE

// source: google/protobuf/descriptor.proto

// Protobuf C++ Version: 5.29.3

#ifndef google_2fprotobuf_2fdescriptor_2eproto_2epb_2eh

#define google_2fprotobuf_2fdescriptor_2eproto_2epb_2eh

#include <limits>

#include <string>

#include <type_traits>

#include <utility>

#include "google/protobuf/runtime_version.h"

#if PROTOBUF_VERSION != 5029003

#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"

// @@protoc_insertion_point(includes)

// Must be included last.

#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fdescriptor_2eproto PROTOBUF_EXPORT

namespace google {

namespace protobuf {

namespace internal {

template <typename T>

::absl::string_view GetAnyMessageName();

}  // namespace internal

}  // namespace protobuf

}  // namespace google

// Internal implementation detail -- do not use these members.

struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fdescriptor_2eproto {

  static const ::uint32_t offsets[];

};

PROTOBUF_EXPORT extern const ::google::protobuf::internal::DescriptorTable

    descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;

namespace google {

namespace protobuf {

class DescriptorProto;

struct DescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;

class DescriptorProto_ExtensionRange;

struct DescriptorProto_ExtensionRangeDefaultTypeInternal;

PROTOBUF_EXPORT extern DescriptorProto_ExtensionRangeDefaultTypeInternal _DescriptorProto_ExtensionRange_default_instance_;

class DescriptorProto_ReservedRange;

struct DescriptorProto_ReservedRangeDefaultTypeInternal;

PROTOBUF_EXPORT extern DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;

class EnumDescriptorProto;

struct EnumDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;

class EnumDescriptorProto_EnumReservedRange;

struct EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal;

PROTOBUF_EXPORT extern EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal _EnumDescriptorProto_EnumReservedRange_default_instance_;

class EnumOptions;

struct EnumOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern EnumOptionsDefaultTypeInternal _EnumOptions_default_instance_;

class EnumValueDescriptorProto;

struct EnumValueDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;

class EnumValueOptions;

struct EnumValueOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern EnumValueOptionsDefaultTypeInternal _EnumValueOptions_default_instance_;

class ExtensionRangeOptions;

struct ExtensionRangeOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern ExtensionRangeOptionsDefaultTypeInternal _ExtensionRangeOptions_default_instance_;

class ExtensionRangeOptions_Declaration;

struct ExtensionRangeOptions_DeclarationDefaultTypeInternal;

PROTOBUF_EXPORT extern ExtensionRangeOptions_DeclarationDefaultTypeInternal _ExtensionRangeOptions_Declaration_default_instance_;

class FeatureSet;

struct FeatureSetDefaultTypeInternal;

PROTOBUF_EXPORT extern FeatureSetDefaultTypeInternal _FeatureSet_default_instance_;

class FeatureSetDefaults;

struct FeatureSetDefaultsDefaultTypeInternal;

PROTOBUF_EXPORT extern FeatureSetDefaultsDefaultTypeInternal _FeatureSetDefaults_default_instance_;

class FeatureSetDefaults_FeatureSetEditionDefault;

struct FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal;

PROTOBUF_EXPORT extern FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal _FeatureSetDefaults_FeatureSetEditionDefault_default_instance_;

class FieldDescriptorProto;

struct FieldDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;

class FieldOptions;

struct FieldOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;

class FieldOptions_EditionDefault;

struct FieldOptions_EditionDefaultDefaultTypeInternal;

PROTOBUF_EXPORT extern FieldOptions_EditionDefaultDefaultTypeInternal _FieldOptions_EditionDefault_default_instance_;

class FieldOptions_FeatureSupport;

struct FieldOptions_FeatureSupportDefaultTypeInternal;

PROTOBUF_EXPORT extern FieldOptions_FeatureSupportDefaultTypeInternal _FieldOptions_FeatureSupport_default_instance_;

class FileDescriptorProto;

struct FileDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;

class FileDescriptorSet;

struct FileDescriptorSetDefaultTypeInternal;

PROTOBUF_EXPORT extern FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;

class FileOptions;

struct FileOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern FileOptionsDefaultTypeInternal _FileOptions_default_instance_;

class GeneratedCodeInfo;

struct GeneratedCodeInfoDefaultTypeInternal;

PROTOBUF_EXPORT extern GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;

class GeneratedCodeInfo_Annotation;

struct GeneratedCodeInfo_AnnotationDefaultTypeInternal;

PROTOBUF_EXPORT extern GeneratedCodeInfo_AnnotationDefaultTypeInternal _GeneratedCodeInfo_Annotation_default_instance_;

class MessageOptions;

struct MessageOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern MessageOptionsDefaultTypeInternal _MessageOptions_default_instance_;

class MethodDescriptorProto;

struct MethodDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern MethodDescriptorProtoDefaultTypeInternal _MethodDescriptorProto_default_instance_;

class MethodOptions;

struct MethodOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern MethodOptionsDefaultTypeInternal _MethodOptions_default_instance_;

class OneofDescriptorProto;

struct OneofDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;

class OneofOptions;

struct OneofOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;

class ServiceDescriptorProto;

struct ServiceDescriptorProtoDefaultTypeInternal;

PROTOBUF_EXPORT extern ServiceDescriptorProtoDefaultTypeInternal _ServiceDescriptorProto_default_instance_;

class ServiceOptions;

struct ServiceOptionsDefaultTypeInternal;

PROTOBUF_EXPORT extern ServiceOptionsDefaultTypeInternal _ServiceOptions_default_instance_;

class SourceCodeInfo;

struct SourceCodeInfoDefaultTypeInternal;

PROTOBUF_EXPORT extern SourceCodeInfoDefaultTypeInternal _SourceCodeInfo_default_instance_;

class SourceCodeInfo_Location;

struct SourceCodeInfo_LocationDefaultTypeInternal;

PROTOBUF_EXPORT extern SourceCodeInfo_LocationDefaultTypeInternal _SourceCodeInfo_Location_default_instance_;

class UninterpretedOption;

struct UninterpretedOptionDefaultTypeInternal;

PROTOBUF_EXPORT extern UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;

class UninterpretedOption_NamePart;

struct UninterpretedOption_NamePartDefaultTypeInternal;

PROTOBUF_EXPORT extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;

namespace internal {

#if !defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)

PROTOBUF_EXPORT void InitializeFileDescriptorDefaultInstancesSlow();

#endif  // !defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)

}  // namespace internal

}  // namespace protobuf

}  // namespace google

namespace google {

namespace protobuf {

enum ExtensionRangeOptions_VerificationState : int {

  ExtensionRangeOptions_VerificationState_DECLARATION = 0,

  ExtensionRangeOptions_VerificationState_UNVERIFIED = 1,

};

PROTOBUF_EXPORT bool ExtensionRangeOptions_VerificationState_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t ExtensionRangeOptions_VerificationState_internal_data_[];

constexpr ExtensionRangeOptions_VerificationState ExtensionRangeOptions_VerificationState_VerificationState_MIN = static_cast<ExtensionRangeOptions_VerificationState>(0);

constexpr ExtensionRangeOptions_VerificationState ExtensionRangeOptions_VerificationState_VerificationState_MAX = static_cast<ExtensionRangeOptions_VerificationState>(1);

constexpr int ExtensionRangeOptions_VerificationState_VerificationState_ARRAYSIZE = 1 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

ExtensionRangeOptions_VerificationState_descriptor();

template <typename T>

const std::string& ExtensionRangeOptions_VerificationState_Name(T value) {

  static_assert(std::is_same<T, ExtensionRangeOptions_VerificationState>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to VerificationState_Name().");

  return ExtensionRangeOptions_VerificationState_Name(static_cast<ExtensionRangeOptions_VerificationState>(value));

}

template <>

inline const std::string& ExtensionRangeOptions_VerificationState_Name(ExtensionRangeOptions_VerificationState value) {

  return ::google::protobuf::internal::NameOfDenseEnum<ExtensionRangeOptions_VerificationState_descriptor,

                                                 0, 1>(

      static_cast<int>(value));

}

inline bool ExtensionRangeOptions_VerificationState_Parse(absl::string_view name, ExtensionRangeOptions_VerificationState* value) {

  return ::google::protobuf::internal::ParseNamedEnum<ExtensionRangeOptions_VerificationState>(

      ExtensionRangeOptions_VerificationState_descriptor(), name, value);

}

enum FieldDescriptorProto_Type : int {

  FieldDescriptorProto_Type_TYPE_DOUBLE = 1,

  FieldDescriptorProto_Type_TYPE_FLOAT = 2,

  FieldDescriptorProto_Type_TYPE_INT64 = 3,

  FieldDescriptorProto_Type_TYPE_UINT64 = 4,

  FieldDescriptorProto_Type_TYPE_INT32 = 5,

  FieldDescriptorProto_Type_TYPE_FIXED64 = 6,

  FieldDescriptorProto_Type_TYPE_FIXED32 = 7,

  FieldDescriptorProto_Type_TYPE_BOOL = 8,

  FieldDescriptorProto_Type_TYPE_STRING = 9,

  FieldDescriptorProto_Type_TYPE_GROUP = 10,

  FieldDescriptorProto_Type_TYPE_MESSAGE = 11,

  FieldDescriptorProto_Type_TYPE_BYTES = 12,

  FieldDescriptorProto_Type_TYPE_UINT32 = 13,

  FieldDescriptorProto_Type_TYPE_ENUM = 14,

  FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,

  FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,

  FieldDescriptorProto_Type_TYPE_SINT32 = 17,

  FieldDescriptorProto_Type_TYPE_SINT64 = 18,

};

PROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FieldDescriptorProto_Type_internal_data_[];

constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = static_cast<FieldDescriptorProto_Type>(1);

constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = static_cast<FieldDescriptorProto_Type>(18);

constexpr int FieldDescriptorProto_Type_Type_ARRAYSIZE = 18 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FieldDescriptorProto_Type_descriptor();

template <typename T>

const std::string& FieldDescriptorProto_Type_Name(T value) {

  static_assert(std::is_same<T, FieldDescriptorProto_Type>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to Type_Name().");

  return FieldDescriptorProto_Type_Name(static_cast<FieldDescriptorProto_Type>(value));

}

template <>

inline const std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FieldDescriptorProto_Type_descriptor,

                                                 1, 18>(

      static_cast<int>(value));

}

inline bool FieldDescriptorProto_Type_Parse(absl::string_view name, FieldDescriptorProto_Type* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Type>(

      FieldDescriptorProto_Type_descriptor(), name, value);

}

enum FieldDescriptorProto_Label : int {

  FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,

  FieldDescriptorProto_Label_LABEL_REPEATED = 3,

  FieldDescriptorProto_Label_LABEL_REQUIRED = 2,

};

PROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FieldDescriptorProto_Label_internal_data_[];

constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = static_cast<FieldDescriptorProto_Label>(1);

constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = static_cast<FieldDescriptorProto_Label>(3);

constexpr int FieldDescriptorProto_Label_Label_ARRAYSIZE = 3 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FieldDescriptorProto_Label_descriptor();

template <typename T>

const std::string& FieldDescriptorProto_Label_Name(T value) {

  static_assert(std::is_same<T, FieldDescriptorProto_Label>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to Label_Name().");

  return FieldDescriptorProto_Label_Name(static_cast<FieldDescriptorProto_Label>(value));

}

template <>

inline const std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FieldDescriptorProto_Label_descriptor,

                                                 1, 3>(

      static_cast<int>(value));

}

inline bool FieldDescriptorProto_Label_Parse(absl::string_view name, FieldDescriptorProto_Label* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Label>(

      FieldDescriptorProto_Label_descriptor(), name, value);

}

enum FileOptions_OptimizeMode : int {

  FileOptions_OptimizeMode_SPEED = 1,

  FileOptions_OptimizeMode_CODE_SIZE = 2,

  FileOptions_OptimizeMode_LITE_RUNTIME = 3,

};

PROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FileOptions_OptimizeMode_internal_data_[];

constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = static_cast<FileOptions_OptimizeMode>(1);

constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = static_cast<FileOptions_OptimizeMode>(3);

constexpr int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = 3 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FileOptions_OptimizeMode_descriptor();

template <typename T>

const std::string& FileOptions_OptimizeMode_Name(T value) {

  static_assert(std::is_same<T, FileOptions_OptimizeMode>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to OptimizeMode_Name().");

  return FileOptions_OptimizeMode_Name(static_cast<FileOptions_OptimizeMode>(value));

}

template <>

inline const std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FileOptions_OptimizeMode_descriptor,

                                                 1, 3>(

      static_cast<int>(value));

}

inline bool FileOptions_OptimizeMode_Parse(absl::string_view name, FileOptions_OptimizeMode* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FileOptions_OptimizeMode>(

      FileOptions_OptimizeMode_descriptor(), name, value);

}

enum FieldOptions_CType : int {

  FieldOptions_CType_STRING = 0,

  FieldOptions_CType_CORD = 1,

  FieldOptions_CType_STRING_PIECE = 2,

};

PROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FieldOptions_CType_internal_data_[];

constexpr FieldOptions_CType FieldOptions_CType_CType_MIN = static_cast<FieldOptions_CType>(0);

constexpr FieldOptions_CType FieldOptions_CType_CType_MAX = static_cast<FieldOptions_CType>(2);

constexpr int FieldOptions_CType_CType_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FieldOptions_CType_descriptor();

template <typename T>

const std::string& FieldOptions_CType_Name(T value) {

  static_assert(std::is_same<T, FieldOptions_CType>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to CType_Name().");

  return FieldOptions_CType_Name(static_cast<FieldOptions_CType>(value));

}

template <>

inline const std::string& FieldOptions_CType_Name(FieldOptions_CType value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FieldOptions_CType_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FieldOptions_CType_Parse(absl::string_view name, FieldOptions_CType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_CType>(

      FieldOptions_CType_descriptor(), name, value);

}

enum FieldOptions_JSType : int {

  FieldOptions_JSType_JS_NORMAL = 0,

  FieldOptions_JSType_JS_STRING = 1,

  FieldOptions_JSType_JS_NUMBER = 2,

};

PROTOBUF_EXPORT bool FieldOptions_JSType_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FieldOptions_JSType_internal_data_[];

constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MIN = static_cast<FieldOptions_JSType>(0);

constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MAX = static_cast<FieldOptions_JSType>(2);

constexpr int FieldOptions_JSType_JSType_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FieldOptions_JSType_descriptor();

template <typename T>

const std::string& FieldOptions_JSType_Name(T value) {

  static_assert(std::is_same<T, FieldOptions_JSType>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to JSType_Name().");

  return FieldOptions_JSType_Name(static_cast<FieldOptions_JSType>(value));

}

template <>

inline const std::string& FieldOptions_JSType_Name(FieldOptions_JSType value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FieldOptions_JSType_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FieldOptions_JSType_Parse(absl::string_view name, FieldOptions_JSType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_JSType>(

      FieldOptions_JSType_descriptor(), name, value);

}

enum FieldOptions_OptionRetention : int {

  FieldOptions_OptionRetention_RETENTION_UNKNOWN = 0,

  FieldOptions_OptionRetention_RETENTION_RUNTIME = 1,

  FieldOptions_OptionRetention_RETENTION_SOURCE = 2,

};

PROTOBUF_EXPORT bool FieldOptions_OptionRetention_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FieldOptions_OptionRetention_internal_data_[];

constexpr FieldOptions_OptionRetention FieldOptions_OptionRetention_OptionRetention_MIN = static_cast<FieldOptions_OptionRetention>(0);

constexpr FieldOptions_OptionRetention FieldOptions_OptionRetention_OptionRetention_MAX = static_cast<FieldOptions_OptionRetention>(2);

constexpr int FieldOptions_OptionRetention_OptionRetention_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FieldOptions_OptionRetention_descriptor();

template <typename T>

const std::string& FieldOptions_OptionRetention_Name(T value) {

  static_assert(std::is_same<T, FieldOptions_OptionRetention>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to OptionRetention_Name().");

  return FieldOptions_OptionRetention_Name(static_cast<FieldOptions_OptionRetention>(value));

}

template <>

inline const std::string& FieldOptions_OptionRetention_Name(FieldOptions_OptionRetention value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FieldOptions_OptionRetention_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FieldOptions_OptionRetention_Parse(absl::string_view name, FieldOptions_OptionRetention* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_OptionRetention>(

      FieldOptions_OptionRetention_descriptor(), name, value);

}

enum FieldOptions_OptionTargetType : int {

  FieldOptions_OptionTargetType_TARGET_TYPE_UNKNOWN = 0,

  FieldOptions_OptionTargetType_TARGET_TYPE_FILE = 1,

  FieldOptions_OptionTargetType_TARGET_TYPE_EXTENSION_RANGE = 2,

  FieldOptions_OptionTargetType_TARGET_TYPE_MESSAGE = 3,

  FieldOptions_OptionTargetType_TARGET_TYPE_FIELD = 4,

  FieldOptions_OptionTargetType_TARGET_TYPE_ONEOF = 5,

  FieldOptions_OptionTargetType_TARGET_TYPE_ENUM = 6,

  FieldOptions_OptionTargetType_TARGET_TYPE_ENUM_ENTRY = 7,

  FieldOptions_OptionTargetType_TARGET_TYPE_SERVICE = 8,

  FieldOptions_OptionTargetType_TARGET_TYPE_METHOD = 9,

};

PROTOBUF_EXPORT bool FieldOptions_OptionTargetType_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FieldOptions_OptionTargetType_internal_data_[];

constexpr FieldOptions_OptionTargetType FieldOptions_OptionTargetType_OptionTargetType_MIN = static_cast<FieldOptions_OptionTargetType>(0);

constexpr FieldOptions_OptionTargetType FieldOptions_OptionTargetType_OptionTargetType_MAX = static_cast<FieldOptions_OptionTargetType>(9);

constexpr int FieldOptions_OptionTargetType_OptionTargetType_ARRAYSIZE = 9 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FieldOptions_OptionTargetType_descriptor();

template <typename T>

const std::string& FieldOptions_OptionTargetType_Name(T value) {

  static_assert(std::is_same<T, FieldOptions_OptionTargetType>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to OptionTargetType_Name().");

  return FieldOptions_OptionTargetType_Name(static_cast<FieldOptions_OptionTargetType>(value));

}

template <>

inline const std::string& FieldOptions_OptionTargetType_Name(FieldOptions_OptionTargetType value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FieldOptions_OptionTargetType_descriptor,

                                                 0, 9>(

      static_cast<int>(value));

}

inline bool FieldOptions_OptionTargetType_Parse(absl::string_view name, FieldOptions_OptionTargetType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_OptionTargetType>(

      FieldOptions_OptionTargetType_descriptor(), name, value);

}

enum MethodOptions_IdempotencyLevel : int {

  MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,

  MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,

  MethodOptions_IdempotencyLevel_IDEMPOTENT = 2,

};

PROTOBUF_EXPORT bool MethodOptions_IdempotencyLevel_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t MethodOptions_IdempotencyLevel_internal_data_[];

constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN = static_cast<MethodOptions_IdempotencyLevel>(0);

constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX = static_cast<MethodOptions_IdempotencyLevel>(2);

constexpr int MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

MethodOptions_IdempotencyLevel_descriptor();

template <typename T>

const std::string& MethodOptions_IdempotencyLevel_Name(T value) {

  static_assert(std::is_same<T, MethodOptions_IdempotencyLevel>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to IdempotencyLevel_Name().");

  return MethodOptions_IdempotencyLevel_Name(static_cast<MethodOptions_IdempotencyLevel>(value));

}

template <>

inline const std::string& MethodOptions_IdempotencyLevel_Name(MethodOptions_IdempotencyLevel value) {

  return ::google::protobuf::internal::NameOfDenseEnum<MethodOptions_IdempotencyLevel_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool MethodOptions_IdempotencyLevel_Parse(absl::string_view name, MethodOptions_IdempotencyLevel* value) {

  return ::google::protobuf::internal::ParseNamedEnum<MethodOptions_IdempotencyLevel>(

      MethodOptions_IdempotencyLevel_descriptor(), name, value);

}

enum FeatureSet_FieldPresence : int {

  FeatureSet_FieldPresence_FIELD_PRESENCE_UNKNOWN = 0,

  FeatureSet_FieldPresence_EXPLICIT = 1,

  FeatureSet_FieldPresence_IMPLICIT = 2,

  FeatureSet_FieldPresence_LEGACY_REQUIRED = 3,

};

PROTOBUF_EXPORT bool FeatureSet_FieldPresence_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FeatureSet_FieldPresence_internal_data_[];

constexpr FeatureSet_FieldPresence FeatureSet_FieldPresence_FieldPresence_MIN = static_cast<FeatureSet_FieldPresence>(0);

constexpr FeatureSet_FieldPresence FeatureSet_FieldPresence_FieldPresence_MAX = static_cast<FeatureSet_FieldPresence>(3);

constexpr int FeatureSet_FieldPresence_FieldPresence_ARRAYSIZE = 3 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FeatureSet_FieldPresence_descriptor();

template <typename T>

const std::string& FeatureSet_FieldPresence_Name(T value) {

  static_assert(std::is_same<T, FeatureSet_FieldPresence>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to FieldPresence_Name().");

  return FeatureSet_FieldPresence_Name(static_cast<FeatureSet_FieldPresence>(value));

}

template <>

inline const std::string& FeatureSet_FieldPresence_Name(FeatureSet_FieldPresence value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FeatureSet_FieldPresence_descriptor,

                                                 0, 3>(

      static_cast<int>(value));

}

inline bool FeatureSet_FieldPresence_Parse(absl::string_view name, FeatureSet_FieldPresence* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FeatureSet_FieldPresence>(

      FeatureSet_FieldPresence_descriptor(), name, value);

}

enum FeatureSet_EnumType : int {

  FeatureSet_EnumType_ENUM_TYPE_UNKNOWN = 0,

  FeatureSet_EnumType_OPEN = 1,

  FeatureSet_EnumType_CLOSED = 2,

};

PROTOBUF_EXPORT bool FeatureSet_EnumType_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FeatureSet_EnumType_internal_data_[];

constexpr FeatureSet_EnumType FeatureSet_EnumType_EnumType_MIN = static_cast<FeatureSet_EnumType>(0);

constexpr FeatureSet_EnumType FeatureSet_EnumType_EnumType_MAX = static_cast<FeatureSet_EnumType>(2);

constexpr int FeatureSet_EnumType_EnumType_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FeatureSet_EnumType_descriptor();

template <typename T>

const std::string& FeatureSet_EnumType_Name(T value) {

  static_assert(std::is_same<T, FeatureSet_EnumType>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to EnumType_Name().");

  return FeatureSet_EnumType_Name(static_cast<FeatureSet_EnumType>(value));

}

template <>

inline const std::string& FeatureSet_EnumType_Name(FeatureSet_EnumType value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FeatureSet_EnumType_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FeatureSet_EnumType_Parse(absl::string_view name, FeatureSet_EnumType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FeatureSet_EnumType>(

      FeatureSet_EnumType_descriptor(), name, value);

}

enum FeatureSet_RepeatedFieldEncoding : int {

  FeatureSet_RepeatedFieldEncoding_REPEATED_FIELD_ENCODING_UNKNOWN = 0,

  FeatureSet_RepeatedFieldEncoding_PACKED = 1,

  FeatureSet_RepeatedFieldEncoding_EXPANDED = 2,

};

PROTOBUF_EXPORT bool FeatureSet_RepeatedFieldEncoding_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FeatureSet_RepeatedFieldEncoding_internal_data_[];

constexpr FeatureSet_RepeatedFieldEncoding FeatureSet_RepeatedFieldEncoding_RepeatedFieldEncoding_MIN = static_cast<FeatureSet_RepeatedFieldEncoding>(0);

constexpr FeatureSet_RepeatedFieldEncoding FeatureSet_RepeatedFieldEncoding_RepeatedFieldEncoding_MAX = static_cast<FeatureSet_RepeatedFieldEncoding>(2);

constexpr int FeatureSet_RepeatedFieldEncoding_RepeatedFieldEncoding_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FeatureSet_RepeatedFieldEncoding_descriptor();

template <typename T>

const std::string& FeatureSet_RepeatedFieldEncoding_Name(T value) {

  static_assert(std::is_same<T, FeatureSet_RepeatedFieldEncoding>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to RepeatedFieldEncoding_Name().");

  return FeatureSet_RepeatedFieldEncoding_Name(static_cast<FeatureSet_RepeatedFieldEncoding>(value));

}

template <>

inline const std::string& FeatureSet_RepeatedFieldEncoding_Name(FeatureSet_RepeatedFieldEncoding value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FeatureSet_RepeatedFieldEncoding_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FeatureSet_RepeatedFieldEncoding_Parse(absl::string_view name, FeatureSet_RepeatedFieldEncoding* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FeatureSet_RepeatedFieldEncoding>(

      FeatureSet_RepeatedFieldEncoding_descriptor(), name, value);

}

enum FeatureSet_Utf8Validation : int {

  FeatureSet_Utf8Validation_UTF8_VALIDATION_UNKNOWN = 0,

  FeatureSet_Utf8Validation_VERIFY = 2,

  FeatureSet_Utf8Validation_NONE = 3,

};

PROTOBUF_EXPORT bool FeatureSet_Utf8Validation_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FeatureSet_Utf8Validation_internal_data_[];

constexpr FeatureSet_Utf8Validation FeatureSet_Utf8Validation_Utf8Validation_MIN = static_cast<FeatureSet_Utf8Validation>(0);

constexpr FeatureSet_Utf8Validation FeatureSet_Utf8Validation_Utf8Validation_MAX = static_cast<FeatureSet_Utf8Validation>(3);

constexpr int FeatureSet_Utf8Validation_Utf8Validation_ARRAYSIZE = 3 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FeatureSet_Utf8Validation_descriptor();

template <typename T>

const std::string& FeatureSet_Utf8Validation_Name(T value) {

  static_assert(std::is_same<T, FeatureSet_Utf8Validation>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to Utf8Validation_Name().");

  return FeatureSet_Utf8Validation_Name(static_cast<FeatureSet_Utf8Validation>(value));

}

template <>

inline const std::string& FeatureSet_Utf8Validation_Name(FeatureSet_Utf8Validation value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FeatureSet_Utf8Validation_descriptor,

                                                 0, 3>(

      static_cast<int>(value));

}

inline bool FeatureSet_Utf8Validation_Parse(absl::string_view name, FeatureSet_Utf8Validation* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FeatureSet_Utf8Validation>(

      FeatureSet_Utf8Validation_descriptor(), name, value);

}

enum FeatureSet_MessageEncoding : int {

  FeatureSet_MessageEncoding_MESSAGE_ENCODING_UNKNOWN = 0,

  FeatureSet_MessageEncoding_LENGTH_PREFIXED = 1,

  FeatureSet_MessageEncoding_DELIMITED = 2,

};

PROTOBUF_EXPORT bool FeatureSet_MessageEncoding_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FeatureSet_MessageEncoding_internal_data_[];

constexpr FeatureSet_MessageEncoding FeatureSet_MessageEncoding_MessageEncoding_MIN = static_cast<FeatureSet_MessageEncoding>(0);

constexpr FeatureSet_MessageEncoding FeatureSet_MessageEncoding_MessageEncoding_MAX = static_cast<FeatureSet_MessageEncoding>(2);

constexpr int FeatureSet_MessageEncoding_MessageEncoding_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FeatureSet_MessageEncoding_descriptor();

template <typename T>

const std::string& FeatureSet_MessageEncoding_Name(T value) {

  static_assert(std::is_same<T, FeatureSet_MessageEncoding>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to MessageEncoding_Name().");

  return FeatureSet_MessageEncoding_Name(static_cast<FeatureSet_MessageEncoding>(value));

}

template <>

inline const std::string& FeatureSet_MessageEncoding_Name(FeatureSet_MessageEncoding value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FeatureSet_MessageEncoding_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FeatureSet_MessageEncoding_Parse(absl::string_view name, FeatureSet_MessageEncoding* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FeatureSet_MessageEncoding>(

      FeatureSet_MessageEncoding_descriptor(), name, value);

}

enum FeatureSet_JsonFormat : int {

  FeatureSet_JsonFormat_JSON_FORMAT_UNKNOWN = 0,

  FeatureSet_JsonFormat_ALLOW = 1,

  FeatureSet_JsonFormat_LEGACY_BEST_EFFORT = 2,

};

PROTOBUF_EXPORT bool FeatureSet_JsonFormat_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t FeatureSet_JsonFormat_internal_data_[];

constexpr FeatureSet_JsonFormat FeatureSet_JsonFormat_JsonFormat_MIN = static_cast<FeatureSet_JsonFormat>(0);

constexpr FeatureSet_JsonFormat FeatureSet_JsonFormat_JsonFormat_MAX = static_cast<FeatureSet_JsonFormat>(2);

constexpr int FeatureSet_JsonFormat_JsonFormat_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

FeatureSet_JsonFormat_descriptor();

template <typename T>

const std::string& FeatureSet_JsonFormat_Name(T value) {

  static_assert(std::is_same<T, FeatureSet_JsonFormat>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to JsonFormat_Name().");

  return FeatureSet_JsonFormat_Name(static_cast<FeatureSet_JsonFormat>(value));

}

template <>

inline const std::string& FeatureSet_JsonFormat_Name(FeatureSet_JsonFormat value) {

  return ::google::protobuf::internal::NameOfDenseEnum<FeatureSet_JsonFormat_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool FeatureSet_JsonFormat_Parse(absl::string_view name, FeatureSet_JsonFormat* value) {

  return ::google::protobuf::internal::ParseNamedEnum<FeatureSet_JsonFormat>(

      FeatureSet_JsonFormat_descriptor(), name, value);

}

enum GeneratedCodeInfo_Annotation_Semantic : int {

  GeneratedCodeInfo_Annotation_Semantic_NONE = 0,

  GeneratedCodeInfo_Annotation_Semantic_SET = 1,

  GeneratedCodeInfo_Annotation_Semantic_ALIAS = 2,

};

PROTOBUF_EXPORT bool GeneratedCodeInfo_Annotation_Semantic_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t GeneratedCodeInfo_Annotation_Semantic_internal_data_[];

constexpr GeneratedCodeInfo_Annotation_Semantic GeneratedCodeInfo_Annotation_Semantic_Semantic_MIN = static_cast<GeneratedCodeInfo_Annotation_Semantic>(0);

constexpr GeneratedCodeInfo_Annotation_Semantic GeneratedCodeInfo_Annotation_Semantic_Semantic_MAX = static_cast<GeneratedCodeInfo_Annotation_Semantic>(2);

constexpr int GeneratedCodeInfo_Annotation_Semantic_Semantic_ARRAYSIZE = 2 + 1;

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

GeneratedCodeInfo_Annotation_Semantic_descriptor();

template <typename T>

const std::string& GeneratedCodeInfo_Annotation_Semantic_Name(T value) {

  static_assert(std::is_same<T, GeneratedCodeInfo_Annotation_Semantic>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to Semantic_Name().");

  return GeneratedCodeInfo_Annotation_Semantic_Name(static_cast<GeneratedCodeInfo_Annotation_Semantic>(value));

}

template <>

inline const std::string& GeneratedCodeInfo_Annotation_Semantic_Name(GeneratedCodeInfo_Annotation_Semantic value) {

  return ::google::protobuf::internal::NameOfDenseEnum<GeneratedCodeInfo_Annotation_Semantic_descriptor,

                                                 0, 2>(

      static_cast<int>(value));

}

inline bool GeneratedCodeInfo_Annotation_Semantic_Parse(absl::string_view name, GeneratedCodeInfo_Annotation_Semantic* value) {

  return ::google::protobuf::internal::ParseNamedEnum<GeneratedCodeInfo_Annotation_Semantic>(

      GeneratedCodeInfo_Annotation_Semantic_descriptor(), name, value);

}

enum Edition : int {

  EDITION_UNKNOWN = 0,

  EDITION_LEGACY = 900,

  EDITION_PROTO2 = 998,

  EDITION_PROTO3 = 999,

  EDITION_2023 = 1000,

  EDITION_2024 = 1001,

  EDITION_1_TEST_ONLY = 1,

  EDITION_2_TEST_ONLY = 2,

  EDITION_99997_TEST_ONLY = 99997,

  EDITION_99998_TEST_ONLY = 99998,

  EDITION_99999_TEST_ONLY = 99999,

  EDITION_MAX = 2147483647,

};

PROTOBUF_EXPORT bool Edition_IsValid(int value);

PROTOBUF_EXPORT extern const uint32_t Edition_internal_data_[];

constexpr Edition Edition_MIN = static_cast<Edition>(0);

constexpr Edition Edition_MAX = static_cast<Edition>(2147483647);

PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*

Edition_descriptor();

template <typename T>

const std::string& Edition_Name(T value) {

  static_assert(std::is_same<T, Edition>::value ||

                    std::is_integral<T>::value,

                "Incorrect type passed to Edition_Name().");

  return ::google::protobuf::internal::NameOfEnum(Edition_descriptor(), value);

}

inline bool Edition_Parse(absl::string_view name, Edition* value) {

  return ::google::protobuf::internal::ParseNamedEnum<Edition>(

      Edition_descriptor(), name, value);

}

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

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

class PROTOBUF_EXPORT UninterpretedOption_NamePart final : public ::google::protobuf::Message

/* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ {

 public:

  inline UninterpretedOption_NamePart() : UninterpretedOption_NamePart(nullptr) {}

  ~UninterpretedOption_NamePart() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)

  void operator delete(UninterpretedOption_NamePart* msg, std::destroying_delete_t) {

    SharedDtor(*msg);

    ::google::protobuf::internal::SizedDelete(msg, sizeof(UninterpretedOption_NamePart));

  }

#endif

  template <typename = void>

  explicit PROTOBUF_CONSTEXPR UninterpretedOption_NamePart(

      ::google::protobuf::internal::ConstantInitialized);

  inline UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from) : UninterpretedOption_NamePart(nullptr, from) {}

  inline UninterpretedOption_NamePart(UninterpretedOption_NamePart&& from) noexcept

      : UninterpretedOption_NamePart(nullptr, std::move(from)) {}

  inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) {

    CopyFrom(from);

    return *this;

  }

  inline UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&& from) noexcept {

    if (this == &from) return *this;

    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  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);

  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()

      ABSL_ATTRIBUTE_LIFETIME_BOUND {

    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();

  }

  static const ::google::protobuf::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::google::protobuf::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::google::protobuf::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const UninterpretedOption_NamePart& default_instance() {

    return *internal_default_instance();

  }

  static inline const UninterpretedOption_NamePart* internal_default_instance() {

    return reinterpret_cast<const UninterpretedOption_NamePart*>(

        &_UninterpretedOption_NamePart_default_instance_);

  }

  static constexpr int kIndexInFileMessages = 24;

  friend void swap(UninterpretedOption_NamePart& a, UninterpretedOption_NamePart& b) { a.Swap(&b); }

  inline void Swap(UninterpretedOption_NamePart* other) {

    if (other == this) return;

    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {

      InternalSwap(other);

    } else {

      ::google::protobuf::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(UninterpretedOption_NamePart* other) {

    if (other == this) return;

    ABSL_DCHECK(GetArena() == other->GetArena());

    InternalSwap(other);

  }

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

  UninterpretedOption_NamePart* New(::google::protobuf::Arena* arena = nullptr) const {

    return ::google::protobuf::Message::DefaultConstruct<UninterpretedOption_NamePart>(arena);

  }

  using ::google::protobuf::Message::CopyFrom;

  void CopyFrom(const UninterpretedOption_NamePart& from);

  using ::google::protobuf::Message::MergeFrom;

  void MergeFrom(const UninterpretedOption_NamePart& from) { UninterpretedOption_NamePart::MergeImpl(*this, from); }

  private:

  static void MergeImpl(

      ::google::protobuf::MessageLite& to_msg,

      const ::google::protobuf::MessageLite& from_msg);

  public:

  bool IsInitialized() const {

    return IsInitializedImpl(*this);

  }

  private:

  static bool IsInitializedImpl(const MessageLite& msg);

  public:

  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;

  #if defined(PROTOBUF_CUSTOM_VTABLE)

  private:

  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);

  static ::uint8_t* _InternalSerialize(

      const MessageLite& msg, ::uint8_t* target,

      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:

  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }

  ::uint8_t* _InternalSerialize(

      ::uint8_t* target,

      ::google::protobuf::io::EpsCopyOutputStream* stream) const {

    return _InternalSerialize(*this, target, stream);

  }

  #else   // PROTOBUF_CUSTOM_VTABLE

  ::size_t ByteSizeLong() const final;

  ::uint8_t* _InternalSerialize(

      ::uint8_t* target,

      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;

  #endif  // PROTOBUF_CUSTOM_VTABLE

  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::google::protobuf::Arena* arena);

  static void SharedDtor(MessageLite& self);

  void InternalSwap(UninterpretedOption_NamePart* other);

 private:

  template <typename T>

  friend ::absl::string_view(

      ::google::protobuf::internal::GetAnyMessageName)();

  static ::absl::string_view FullMessageName() { return "google.protobuf.UninterpretedOption.NamePart"; }

 protected:

  explicit UninterpretedOption_NamePart(::google::protobuf::Arena* arena);

  UninterpretedOption_NamePart(::google::protobuf::Arena* arena, const UninterpretedOption_NamePart& from);

  UninterpretedOption_NamePart(::google::protobuf::Arena* arena, UninterpretedOption_NamePart&& from) noexcept

      : UninterpretedOption_NamePart(arena) {

    *this = ::std::move(from);

  }

  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;

  static void* PlacementNew_(const void*, void* mem,

                             ::google::protobuf::Arena* arena);

  static constexpr auto InternalNewImpl_();

  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  enum : int {

    kNamePartFieldNumber = 1,

    kIsExtensionFieldNumber = 2,

  };

  // required string name_part = 1;

  bool has_name_part() const;

  void clear_name_part() ;

  const std::string& name_part() const;

  template <typename Arg_ = const std::string&, typename... Args_>

  void set_name_part(Arg_&& arg, Args_... args);

  std::string* mutable_name_part();

  PROTOBUF_NODISCARD std::string* release_name_part();

  void set_allocated_name_part(std::string* value);

  private:

  const std::string& _internal_name_part() const;

  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_part(

      const std::string& value);

  std::string* _internal_mutable_name_part();

  public:

  // required bool is_extension = 2;

  bool has_is_extension() const;

  void clear_is_extension() ;

  bool is_extension() const;

  void set_is_extension(bool value);

  private:

  bool _internal_is_extension() const;

  void _internal_set_is_extension(bool value);

  public:

  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)

 private:

  class _Internal;

  friend class ::google::protobuf::internal::TcParser;

  static const ::google::protobuf::internal::TcParseTable<

      1, 2, 0,

      62, 2>

      _table_;

  friend class ::google::protobuf::MessageLite;

  friend class ::google::protobuf::Arena;

  template <typename T>

  friend class ::google::protobuf::Arena::InternalHelper;

  using InternalArenaConstructable_ = void;

  using DestructorSkippable_ = void;

  struct Impl_ {

    inline explicit constexpr Impl_(

        ::google::protobuf::internal::ConstantInitialized) noexcept;

    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,

                          ::google::protobuf::Arena* arena);

    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,

                          ::google::protobuf::Arena* arena, const Impl_& from,

                          const UninterpretedOption_NamePart& from_msg);

    ::google::protobuf::internal::HasBits<1> _has_bits_;

    ::google::protobuf::internal::CachedSize _cached_size_;

    ::google::protobuf::internal::ArenaStringPtr name_part_;

    bool is_extension_;

    PROTOBUF_TSAN_DECLARE_MEMBER

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;

};

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

class PROTOBUF_EXPORT SourceCodeInfo_Location final : public ::google::protobuf::Message

/* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ {

 public:

  inline SourceCodeInfo_Location() : SourceCodeInfo_Location(nullptr) {}

  ~SourceCodeInfo_Location() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)

  void operator delete(SourceCodeInfo_Location* msg, std::destroying_delete_t) {

    SharedDtor(*msg);

    ::google::protobuf::internal::SizedDelete(msg, sizeof(SourceCodeInfo_Location));

  }

#endif

  template <typename = void>

  explicit PROTOBUF_CONSTEXPR SourceCodeInfo_Location(

      ::google::protobuf::internal::ConstantInitialized);

  inline SourceCodeInfo_Location(const SourceCodeInfo_Location& from) : SourceCodeInfo_Location(nullptr, from) {}

  inline SourceCodeInfo_Location(SourceCodeInfo_Location&& from) noexcept

      : SourceCodeInfo_Location(nullptr, std::move(from)) {}

  inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) {

    CopyFrom(from);

    return *this;

  }

  inline SourceCodeInfo_Location& operator=(SourceCodeInfo_Location&& from) noexcept {

    if (this == &from) return *this;

    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  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);

  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()

      ABSL_ATTRIBUTE_LIFETIME_BOUND {

    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();

  }

  static const ::google::protobuf::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::google::protobuf::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::google::protobuf::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const SourceCodeInfo_Location& default_instance() {

    return *internal_default_instance();

  }

  static inline const SourceCodeInfo_Location* internal_default_instance() {

    return reinterpret_cast<const SourceCodeInfo_Location*>(

        &_SourceCodeInfo_Location_default_instance_);

  }

  static constexpr int kIndexInFileMessages = 29;

  friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b) { a.Swap(&b); }

  inline void Swap(SourceCodeInfo_Location* other) {

    if (other == this) return;

    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {

      InternalSwap(other);

    } else {

      ::google::protobuf::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(SourceCodeInfo_Location* other) {

    if (other == this) return;

    ABSL_DCHECK(GetArena() == other->GetArena());

    InternalSwap(other);

  }

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

  SourceCodeInfo_Location* New(::google::protobuf::Arena* arena = nullptr) const {

    return ::google::protobuf::Message::DefaultConstruct<SourceCodeInfo_Location>(arena);

  }

  using ::google::protobuf::Message::CopyFrom;

  void CopyFrom(const SourceCodeInfo_Location& from);

  using ::google::protobuf::Message::MergeFrom;

  void MergeFrom(const SourceCodeInfo_Location& from) { SourceCodeInfo_Location::MergeImpl(*this, from); }

  private:

  static void MergeImpl(

      ::google::protobuf::MessageLite& to_msg,

      const ::google::protobuf::MessageLite& from_msg);

  public:

  bool IsInitialized() const {

    return true;

  }

  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;

  #if defined(PROTOBUF_CUSTOM_VTABLE)

  private:

  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);

  static ::uint8_t* _InternalSerialize(

      const MessageLite& msg, ::uint8_t* target,

      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:

  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }

  ::uint8_t* _InternalSerialize(

      ::uint8_t* target,

      ::google::protobuf::io::EpsCopyOutputStream* stream) const {

    return _InternalSerialize(*this, target, stream);

  }

  #else   // PROTOBUF_CUSTOM_VTABLE

  ::size_t ByteSizeLong() const final;

  ::uint8_t* _InternalSerialize(

      ::uint8_t* target,

      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;

  #endif  // PROTOBUF_CUSTOM_VTABLE

  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::google::protobuf::Arena* arena);

  static void SharedDtor(MessageLite& self);

  void InternalSwap(SourceCodeInfo_Location* other);

 private:

  template <typename T>

  friend ::absl::string_view(

      ::google::protobuf::internal::GetAnyMessageName)();

  static ::absl::string_view FullMessageName() { return "google.protobuf.SourceCodeInfo.Location"; }

 protected:

  explicit SourceCodeInfo_Location(::google::protobuf::Arena* arena);

  SourceCodeInfo_Location(::google::protobuf::Arena* arena, const SourceCodeInfo_Location& from);

  SourceCodeInfo_Location(::google::protobuf::Arena* arena, SourceCodeInfo_Location&& from) noexcept

      : SourceCodeInfo_Location(arena) {

    *this = ::std::move(from);

  }

  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;

  static void* PlacementNew_(const void*, void* mem,

                             ::google::protobuf::Arena* arena);

  static constexpr auto InternalNewImpl_();

  static const ::google::protobuf::internal::ClassDataFull _class_data_;