chromium/out/Default/gen/third_party/perfetto/protos/perfetto/trace/chrome/v8.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protos/perfetto/trace/chrome/v8.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fv8_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_2ftrace_2fchrome_2fv8_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_2ftrace_2fchrome_2fv8_2eproto {};
namespace perfetto {
namespace protos {
class InternedV8Isolate;
struct InternedV8IsolateDefaultTypeInternal;
extern InternedV8IsolateDefaultTypeInternal _InternedV8Isolate_default_instance_;
class InternedV8Isolate_CodeRange;
struct InternedV8Isolate_CodeRangeDefaultTypeInternal;
extern InternedV8Isolate_CodeRangeDefaultTypeInternal _InternedV8Isolate_CodeRange_default_instance_;
class InternedV8JsFunction;
struct InternedV8JsFunctionDefaultTypeInternal;
extern InternedV8JsFunctionDefaultTypeInternal _InternedV8JsFunction_default_instance_;
class InternedV8JsScript;
struct InternedV8JsScriptDefaultTypeInternal;
extern InternedV8JsScriptDefaultTypeInternal _InternedV8JsScript_default_instance_;
class InternedV8String;
struct InternedV8StringDefaultTypeInternal;
extern InternedV8StringDefaultTypeInternal _InternedV8String_default_instance_;
class InternedV8WasmScript;
struct InternedV8WasmScriptDefaultTypeInternal;
extern InternedV8WasmScriptDefaultTypeInternal _InternedV8WasmScript_default_instance_;
class V8CodeDefaults;
struct V8CodeDefaultsDefaultTypeInternal;
extern V8CodeDefaultsDefaultTypeInternal _V8CodeDefaults_default_instance_;
class V8CodeMove;
struct V8CodeMoveDefaultTypeInternal;
extern V8CodeMoveDefaultTypeInternal _V8CodeMove_default_instance_;
class V8InternalCode;
struct V8InternalCodeDefaultTypeInternal;
extern V8InternalCodeDefaultTypeInternal _V8InternalCode_default_instance_;
class V8JsCode;
struct V8JsCodeDefaultTypeInternal;
extern V8JsCodeDefaultTypeInternal _V8JsCode_default_instance_;
class V8RegExpCode;
struct V8RegExpCodeDefaultTypeInternal;
extern V8RegExpCodeDefaultTypeInternal _V8RegExpCode_default_instance_;
class V8String;
struct V8StringDefaultTypeInternal;
extern V8StringDefaultTypeInternal _V8String_default_instance_;
class V8WasmCode;
struct V8WasmCodeDefaultTypeInternal;
extern V8WasmCodeDefaultTypeInternal _V8WasmCode_default_instance_;
}  // namespace protos
}  // namespace perfetto
PROTOBUF_NAMESPACE_OPEN
template<> ::perfetto::protos::InternedV8Isolate* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8Isolate>(Arena*);
template<> ::perfetto::protos::InternedV8Isolate_CodeRange* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8Isolate_CodeRange>(Arena*);
template<> ::perfetto::protos::InternedV8JsFunction* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8JsFunction>(Arena*);
template<> ::perfetto::protos::InternedV8JsScript* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8JsScript>(Arena*);
template<> ::perfetto::protos::InternedV8String* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8String>(Arena*);
template<> ::perfetto::protos::InternedV8WasmScript* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8WasmScript>(Arena*);
template<> ::perfetto::protos::V8CodeDefaults* Arena::CreateMaybeMessage<::perfetto::protos::V8CodeDefaults>(Arena*);
template<> ::perfetto::protos::V8CodeMove* Arena::CreateMaybeMessage<::perfetto::protos::V8CodeMove>(Arena*);
template<> ::perfetto::protos::V8InternalCode* Arena::CreateMaybeMessage<::perfetto::protos::V8InternalCode>(Arena*);
template<> ::perfetto::protos::V8JsCode* Arena::CreateMaybeMessage<::perfetto::protos::V8JsCode>(Arena*);
template<> ::perfetto::protos::V8RegExpCode* Arena::CreateMaybeMessage<::perfetto::protos::V8RegExpCode>(Arena*);
template<> ::perfetto::protos::V8String* Arena::CreateMaybeMessage<::perfetto::protos::V8String>(Arena*);
template<> ::perfetto::protos::V8WasmCode* Arena::CreateMaybeMessage<::perfetto::protos::V8WasmCode>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace perfetto {
namespace protos {

enum InternedV8JsScript_Type : int {};
bool InternedV8JsScript_Type_IsValid(int value);
constexpr InternedV8JsScript_Type InternedV8JsScript_Type_Type_MIN =;
constexpr InternedV8JsScript_Type InternedV8JsScript_Type_Type_MAX =;
constexpr int InternedV8JsScript_Type_Type_ARRAYSIZE =;

const std::string& InternedV8JsScript_Type_Name(InternedV8JsScript_Type value);
template<typename T>
inline const std::string& InternedV8JsScript_Type_Name(T enum_t_value) {}
bool InternedV8JsScript_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsScript_Type* value);
enum InternedV8JsFunction_Kind : int {};
bool InternedV8JsFunction_Kind_IsValid(int value);
constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_Kind_MIN =;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_Kind_MAX =;
constexpr int InternedV8JsFunction_Kind_Kind_ARRAYSIZE =;

const std::string& InternedV8JsFunction_Kind_Name(InternedV8JsFunction_Kind value);
template<typename T>
inline const std::string& InternedV8JsFunction_Kind_Name(T enum_t_value) {}
bool InternedV8JsFunction_Kind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsFunction_Kind* value);
enum V8JsCode_Tier : int {};
bool V8JsCode_Tier_IsValid(int value);
constexpr V8JsCode_Tier V8JsCode_Tier_Tier_MIN =;
constexpr V8JsCode_Tier V8JsCode_Tier_Tier_MAX =;
constexpr int V8JsCode_Tier_Tier_ARRAYSIZE =;

const std::string& V8JsCode_Tier_Name(V8JsCode_Tier value);
template<typename T>
inline const std::string& V8JsCode_Tier_Name(T enum_t_value) {}
bool V8JsCode_Tier_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8JsCode_Tier* value);
enum V8InternalCode_Type : int {};
bool V8InternalCode_Type_IsValid(int value);
constexpr V8InternalCode_Type V8InternalCode_Type_Type_MIN =;
constexpr V8InternalCode_Type V8InternalCode_Type_Type_MAX =;
constexpr int V8InternalCode_Type_Type_ARRAYSIZE =;

const std::string& V8InternalCode_Type_Name(V8InternalCode_Type value);
template<typename T>
inline const std::string& V8InternalCode_Type_Name(T enum_t_value) {}
bool V8InternalCode_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8InternalCode_Type* value);
enum V8WasmCode_Tier : int {};
bool V8WasmCode_Tier_IsValid(int value);
constexpr V8WasmCode_Tier V8WasmCode_Tier_Tier_MIN =;
constexpr V8WasmCode_Tier V8WasmCode_Tier_Tier_MAX =;
constexpr int V8WasmCode_Tier_Tier_ARRAYSIZE =;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

// bytes latin1 = 1;
inline bool V8String::_internal_has_latin1() const {}
inline bool V8String::has_latin1() const {}
inline void V8String::set_has_latin1() {}
inline void V8String::clear_latin1() {}
inline const std::string& V8String::latin1() const {}
template <typename ArgT0, typename... ArgT>
inline void V8String::set_latin1(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8String::mutable_latin1() {}
inline const std::string& V8String::_internal_latin1() const {}
inline void V8String::_internal_set_latin1(const std::string& value) {}
inline std::string* V8String::_internal_mutable_latin1() {}
inline std::string* V8String::release_latin1() {}
inline void V8String::set_allocated_latin1(std::string* latin1) {}

// bytes utf16_le = 2;
inline bool V8String::_internal_has_utf16_le() const {}
inline bool V8String::has_utf16_le() const {}
inline void V8String::set_has_utf16_le() {}
inline void V8String::clear_utf16_le() {}
inline const std::string& V8String::utf16_le() const {}
template <typename ArgT0, typename... ArgT>
inline void V8String::set_utf16_le(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8String::mutable_utf16_le() {}
inline const std::string& V8String::_internal_utf16_le() const {}
inline void V8String::_internal_set_utf16_le(const std::string& value) {}
inline std::string* V8String::_internal_mutable_utf16_le() {}
inline std::string* V8String::release_utf16_le() {}
inline void V8String::set_allocated_utf16_le(std::string* utf16_le) {}

// bytes utf16_be = 3;
inline bool V8String::_internal_has_utf16_be() const {}
inline bool V8String::has_utf16_be() const {}
inline void V8String::set_has_utf16_be() {}
inline void V8String::clear_utf16_be() {}
inline const std::string& V8String::utf16_be() const {}
template <typename ArgT0, typename... ArgT>
inline void V8String::set_utf16_be(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8String::mutable_utf16_be() {}
inline const std::string& V8String::_internal_utf16_be() const {}
inline void V8String::_internal_set_utf16_be(const std::string& value) {}
inline std::string* V8String::_internal_mutable_utf16_be() {}
inline std::string* V8String::release_utf16_be() {}
inline void V8String::set_allocated_utf16_be(std::string* utf16_be) {}

inline bool V8String::has_encoded_string() const {}
inline void V8String::clear_has_encoded_string() {}
inline V8String::EncodedStringCase V8String::encoded_string_case() const {}
// -------------------------------------------------------------------

// InternedV8String

// optional uint64 iid = 1;
inline bool InternedV8String::_internal_has_iid() const {}
inline bool InternedV8String::has_iid() const {}
inline void InternedV8String::clear_iid() {}
inline uint64_t InternedV8String::_internal_iid() const {}
inline uint64_t InternedV8String::iid() const {}
inline void InternedV8String::_internal_set_iid(uint64_t value) {}
inline void InternedV8String::set_iid(uint64_t value) {}

// bytes latin1 = 2;
inline bool InternedV8String::_internal_has_latin1() const {}
inline bool InternedV8String::has_latin1() const {}
inline void InternedV8String::set_has_latin1() {}
inline void InternedV8String::clear_latin1() {}
inline const std::string& InternedV8String::latin1() const {}
template <typename ArgT0, typename... ArgT>
inline void InternedV8String::set_latin1(ArgT0&& arg0, ArgT... args) {}
inline std::string* InternedV8String::mutable_latin1() {}
inline const std::string& InternedV8String::_internal_latin1() const {}
inline void InternedV8String::_internal_set_latin1(const std::string& value) {}
inline std::string* InternedV8String::_internal_mutable_latin1() {}
inline std::string* InternedV8String::release_latin1() {}
inline void InternedV8String::set_allocated_latin1(std::string* latin1) {}

// bytes utf16_le = 3;
inline bool InternedV8String::_internal_has_utf16_le() const {}
inline bool InternedV8String::has_utf16_le() const {}
inline void InternedV8String::set_has_utf16_le() {}
inline void InternedV8String::clear_utf16_le() {}
inline const std::string& InternedV8String::utf16_le() const {}
template <typename ArgT0, typename... ArgT>
inline void InternedV8String::set_utf16_le(ArgT0&& arg0, ArgT... args) {}
inline std::string* InternedV8String::mutable_utf16_le() {}
inline const std::string& InternedV8String::_internal_utf16_le() const {}
inline void InternedV8String::_internal_set_utf16_le(const std::string& value) {}
inline std::string* InternedV8String::_internal_mutable_utf16_le() {}
inline std::string* InternedV8String::release_utf16_le() {}
inline void InternedV8String::set_allocated_utf16_le(std::string* utf16_le) {}

// bytes utf16_be = 4;
inline bool InternedV8String::_internal_has_utf16_be() const {}
inline bool InternedV8String::has_utf16_be() const {}
inline void InternedV8String::set_has_utf16_be() {}
inline void InternedV8String::clear_utf16_be() {}
inline const std::string& InternedV8String::utf16_be() const {}
template <typename ArgT0, typename... ArgT>
inline void InternedV8String::set_utf16_be(ArgT0&& arg0, ArgT... args) {}
inline std::string* InternedV8String::mutable_utf16_be() {}
inline const std::string& InternedV8String::_internal_utf16_be() const {}
inline void InternedV8String::_internal_set_utf16_be(const std::string& value) {}
inline std::string* InternedV8String::_internal_mutable_utf16_be() {}
inline std::string* InternedV8String::release_utf16_be() {}
inline void InternedV8String::set_allocated_utf16_be(std::string* utf16_be) {}

inline bool InternedV8String::has_encoded_string() const {}
inline void InternedV8String::clear_has_encoded_string() {}
inline InternedV8String::EncodedStringCase InternedV8String::encoded_string_case() const {}
// -------------------------------------------------------------------

// InternedV8JsScript

// optional uint64 iid = 1;
inline bool InternedV8JsScript::_internal_has_iid() const {}
inline bool InternedV8JsScript::has_iid() const {}
inline void InternedV8JsScript::clear_iid() {}
inline uint64_t InternedV8JsScript::_internal_iid() const {}
inline uint64_t InternedV8JsScript::iid() const {}
inline void InternedV8JsScript::_internal_set_iid(uint64_t value) {}
inline void InternedV8JsScript::set_iid(uint64_t value) {}

// optional int32 script_id = 2;
inline bool InternedV8JsScript::_internal_has_script_id() const {}
inline bool InternedV8JsScript::has_script_id() const {}
inline void InternedV8JsScript::clear_script_id() {}
inline int32_t InternedV8JsScript::_internal_script_id() const {}
inline int32_t InternedV8JsScript::script_id() const {}
inline void InternedV8JsScript::_internal_set_script_id(int32_t value) {}
inline void InternedV8JsScript::set_script_id(int32_t value) {}

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

// optional .perfetto.protos.V8String name = 4;
inline bool InternedV8JsScript::_internal_has_name() const {}
inline bool InternedV8JsScript::has_name() const {}
inline void InternedV8JsScript::clear_name() {}
inline const ::perfetto::protos::V8String& InternedV8JsScript::_internal_name() const {}
inline const ::perfetto::protos::V8String& InternedV8JsScript::name() const {}
inline void InternedV8JsScript::unsafe_arena_set_allocated_name(
    ::perfetto::protos::V8String* name) {}
inline ::perfetto::protos::V8String* InternedV8JsScript::release_name() {}
inline ::perfetto::protos::V8String* InternedV8JsScript::unsafe_arena_release_name() {}
inline ::perfetto::protos::V8String* InternedV8JsScript::_internal_mutable_name() {}
inline ::perfetto::protos::V8String* InternedV8JsScript::mutable_name() {}
inline void InternedV8JsScript::set_allocated_name(::perfetto::protos::V8String* name) {}

// optional .perfetto.protos.V8String source = 5;
inline bool InternedV8JsScript::_internal_has_source() const {}
inline bool InternedV8JsScript::has_source() const {}
inline void InternedV8JsScript::clear_source() {}
inline const ::perfetto::protos::V8String& InternedV8JsScript::_internal_source() const {}
inline const ::perfetto::protos::V8String& InternedV8JsScript::source() const {}
inline void InternedV8JsScript::unsafe_arena_set_allocated_source(
    ::perfetto::protos::V8String* source) {}
inline ::perfetto::protos::V8String* InternedV8JsScript::release_source() {}
inline ::perfetto::protos::V8String* InternedV8JsScript::unsafe_arena_release_source() {}
inline ::perfetto::protos::V8String* InternedV8JsScript::_internal_mutable_source() {}
inline ::perfetto::protos::V8String* InternedV8JsScript::mutable_source() {}
inline void InternedV8JsScript::set_allocated_source(::perfetto::protos::V8String* source) {}

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

// InternedV8WasmScript

// optional uint64 iid = 1;
inline bool InternedV8WasmScript::_internal_has_iid() const {}
inline bool InternedV8WasmScript::has_iid() const {}
inline void InternedV8WasmScript::clear_iid() {}
inline uint64_t InternedV8WasmScript::_internal_iid() const {}
inline uint64_t InternedV8WasmScript::iid() const {}
inline void InternedV8WasmScript::_internal_set_iid(uint64_t value) {}
inline void InternedV8WasmScript::set_iid(uint64_t value) {}

// optional int32 script_id = 2;
inline bool InternedV8WasmScript::_internal_has_script_id() const {}
inline bool InternedV8WasmScript::has_script_id() const {}
inline void InternedV8WasmScript::clear_script_id() {}
inline int32_t InternedV8WasmScript::_internal_script_id() const {}
inline int32_t InternedV8WasmScript::script_id() const {}
inline void InternedV8WasmScript::_internal_set_script_id(int32_t value) {}
inline void InternedV8WasmScript::set_script_id(int32_t value) {}

// optional string url = 3;
inline bool InternedV8WasmScript::_internal_has_url() const {}
inline bool InternedV8WasmScript::has_url() const {}
inline void InternedV8WasmScript::clear_url() {}
inline const std::string& InternedV8WasmScript::url() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InternedV8WasmScript::set_url(ArgT0&& arg0, ArgT... args) {}
inline std::string* InternedV8WasmScript::mutable_url() {}
inline const std::string& InternedV8WasmScript::_internal_url() const {}
inline void InternedV8WasmScript::_internal_set_url(const std::string& value) {}
inline std::string* InternedV8WasmScript::_internal_mutable_url() {}
inline std::string* InternedV8WasmScript::release_url() {}
inline void InternedV8WasmScript::set_allocated_url(std::string* url) {}

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

// InternedV8JsFunction

// optional uint64 iid = 1;
inline bool InternedV8JsFunction::_internal_has_iid() const {}
inline bool InternedV8JsFunction::has_iid() const {}
inline void InternedV8JsFunction::clear_iid() {}
inline uint64_t InternedV8JsFunction::_internal_iid() const {}
inline uint64_t InternedV8JsFunction::iid() const {}
inline void InternedV8JsFunction::_internal_set_iid(uint64_t value) {}
inline void InternedV8JsFunction::set_iid(uint64_t value) {}

// optional uint64 v8_js_function_name_iid = 2;
inline bool InternedV8JsFunction::_internal_has_v8_js_function_name_iid() const {}
inline bool InternedV8JsFunction::has_v8_js_function_name_iid() const {}
inline void InternedV8JsFunction::clear_v8_js_function_name_iid() {}
inline uint64_t InternedV8JsFunction::_internal_v8_js_function_name_iid() const {}
inline uint64_t InternedV8JsFunction::v8_js_function_name_iid() const {}
inline void InternedV8JsFunction::_internal_set_v8_js_function_name_iid(uint64_t value) {}
inline void InternedV8JsFunction::set_v8_js_function_name_iid(uint64_t value) {}

// optional uint64 v8_js_script_iid = 3;
inline bool InternedV8JsFunction::_internal_has_v8_js_script_iid() const {}
inline bool InternedV8JsFunction::has_v8_js_script_iid() const {}
inline void InternedV8JsFunction::clear_v8_js_script_iid() {}
inline uint64_t InternedV8JsFunction::_internal_v8_js_script_iid() const {}
inline uint64_t InternedV8JsFunction::v8_js_script_iid() const {}
inline void InternedV8JsFunction::_internal_set_v8_js_script_iid(uint64_t value) {}
inline void InternedV8JsFunction::set_v8_js_script_iid(uint64_t value) {}

// optional bool is_toplevel = 4;
inline bool InternedV8JsFunction::_internal_has_is_toplevel() const {}
inline bool InternedV8JsFunction::has_is_toplevel() const {}
inline void InternedV8JsFunction::clear_is_toplevel() {}
inline bool InternedV8JsFunction::_internal_is_toplevel() const {}
inline bool InternedV8JsFunction::is_toplevel() const {}
inline void InternedV8JsFunction::_internal_set_is_toplevel(bool value) {}
inline void InternedV8JsFunction::set_is_toplevel(bool value) {}

// optional .perfetto.protos.InternedV8JsFunction.Kind kind = 5;
inline bool InternedV8JsFunction::_internal_has_kind() const {}
inline bool InternedV8JsFunction::has_kind() const {}
inline void InternedV8JsFunction::clear_kind() {}
inline ::perfetto::protos::InternedV8JsFunction_Kind InternedV8JsFunction::_internal_kind() const {}
inline ::perfetto::protos::InternedV8JsFunction_Kind InternedV8JsFunction::kind() const {}
inline void InternedV8JsFunction::_internal_set_kind(::perfetto::protos::InternedV8JsFunction_Kind value) {}
inline void InternedV8JsFunction::set_kind(::perfetto::protos::InternedV8JsFunction_Kind value) {}

// optional uint32 byte_offset = 6;
inline bool InternedV8JsFunction::_internal_has_byte_offset() const {}
inline bool InternedV8JsFunction::has_byte_offset() const {}
inline void InternedV8JsFunction::clear_byte_offset() {}
inline uint32_t InternedV8JsFunction::_internal_byte_offset() const {}
inline uint32_t InternedV8JsFunction::byte_offset() const {}
inline void InternedV8JsFunction::_internal_set_byte_offset(uint32_t value) {}
inline void InternedV8JsFunction::set_byte_offset(uint32_t value) {}

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

// InternedV8Isolate_CodeRange

// optional uint64 base_address = 1;
inline bool InternedV8Isolate_CodeRange::_internal_has_base_address() const {}
inline bool InternedV8Isolate_CodeRange::has_base_address() const {}
inline void InternedV8Isolate_CodeRange::clear_base_address() {}
inline uint64_t InternedV8Isolate_CodeRange::_internal_base_address() const {}
inline uint64_t InternedV8Isolate_CodeRange::base_address() const {}
inline void InternedV8Isolate_CodeRange::_internal_set_base_address(uint64_t value) {}
inline void InternedV8Isolate_CodeRange::set_base_address(uint64_t value) {}

// optional uint64 size = 2;
inline bool InternedV8Isolate_CodeRange::_internal_has_size() const {}
inline bool InternedV8Isolate_CodeRange::has_size() const {}
inline void InternedV8Isolate_CodeRange::clear_size() {}
inline uint64_t InternedV8Isolate_CodeRange::_internal_size() const {}
inline uint64_t InternedV8Isolate_CodeRange::size() const {}
inline void InternedV8Isolate_CodeRange::_internal_set_size(uint64_t value) {}
inline void InternedV8Isolate_CodeRange::set_size(uint64_t value) {}

// optional uint64 embedded_blob_code_copy_start_address = 3;
inline bool InternedV8Isolate_CodeRange::_internal_has_embedded_blob_code_copy_start_address() const {}
inline bool InternedV8Isolate_CodeRange::has_embedded_blob_code_copy_start_address() const {}
inline void InternedV8Isolate_CodeRange::clear_embedded_blob_code_copy_start_address() {}
inline uint64_t InternedV8Isolate_CodeRange::_internal_embedded_blob_code_copy_start_address() const {}
inline uint64_t InternedV8Isolate_CodeRange::embedded_blob_code_copy_start_address() const {}
inline void InternedV8Isolate_CodeRange::_internal_set_embedded_blob_code_copy_start_address(uint64_t value) {}
inline void InternedV8Isolate_CodeRange::set_embedded_blob_code_copy_start_address(uint64_t value) {}

// optional bool is_process_wide = 4;
inline bool InternedV8Isolate_CodeRange::_internal_has_is_process_wide() const {}
inline bool InternedV8Isolate_CodeRange::has_is_process_wide() const {}
inline void InternedV8Isolate_CodeRange::clear_is_process_wide() {}
inline bool InternedV8Isolate_CodeRange::_internal_is_process_wide() const {}
inline bool InternedV8Isolate_CodeRange::is_process_wide() const {}
inline void InternedV8Isolate_CodeRange::_internal_set_is_process_wide(bool value) {}
inline void InternedV8Isolate_CodeRange::set_is_process_wide(bool value) {}

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

// InternedV8Isolate

// optional uint64 iid = 1;
inline bool InternedV8Isolate::_internal_has_iid() const {}
inline bool InternedV8Isolate::has_iid() const {}
inline void InternedV8Isolate::clear_iid() {}
inline uint64_t InternedV8Isolate::_internal_iid() const {}
inline uint64_t InternedV8Isolate::iid() const {}
inline void InternedV8Isolate::_internal_set_iid(uint64_t value) {}
inline void InternedV8Isolate::set_iid(uint64_t value) {}

// optional uint32 pid = 2;
inline bool InternedV8Isolate::_internal_has_pid() const {}
inline bool InternedV8Isolate::has_pid() const {}
inline void InternedV8Isolate::clear_pid() {}
inline uint32_t InternedV8Isolate::_internal_pid() const {}
inline uint32_t InternedV8Isolate::pid() const {}
inline void InternedV8Isolate::_internal_set_pid(uint32_t value) {}
inline void InternedV8Isolate::set_pid(uint32_t value) {}

// optional int32 isolate_id = 3;
inline bool InternedV8Isolate::_internal_has_isolate_id() const {}
inline bool InternedV8Isolate::has_isolate_id() const {}
inline void InternedV8Isolate::clear_isolate_id() {}
inline int32_t InternedV8Isolate::_internal_isolate_id() const {}
inline int32_t InternedV8Isolate::isolate_id() const {}
inline void InternedV8Isolate::_internal_set_isolate_id(int32_t value) {}
inline void InternedV8Isolate::set_isolate_id(int32_t value) {}

// optional .perfetto.protos.InternedV8Isolate.CodeRange code_range = 4;
inline bool InternedV8Isolate::_internal_has_code_range() const {}
inline bool InternedV8Isolate::has_code_range() const {}
inline void InternedV8Isolate::clear_code_range() {}
inline const ::perfetto::protos::InternedV8Isolate_CodeRange& InternedV8Isolate::_internal_code_range() const {}
inline const ::perfetto::protos::InternedV8Isolate_CodeRange& InternedV8Isolate::code_range() const {}
inline void InternedV8Isolate::unsafe_arena_set_allocated_code_range(
    ::perfetto::protos::InternedV8Isolate_CodeRange* code_range) {}
inline ::perfetto::protos::InternedV8Isolate_CodeRange* InternedV8Isolate::release_code_range() {}
inline ::perfetto::protos::InternedV8Isolate_CodeRange* InternedV8Isolate::unsafe_arena_release_code_range() {}
inline ::perfetto::protos::InternedV8Isolate_CodeRange* InternedV8Isolate::_internal_mutable_code_range() {}
inline ::perfetto::protos::InternedV8Isolate_CodeRange* InternedV8Isolate::mutable_code_range() {}
inline void InternedV8Isolate::set_allocated_code_range(::perfetto::protos::InternedV8Isolate_CodeRange* code_range) {}

// optional uint64 embedded_blob_code_start_address = 5;
inline bool InternedV8Isolate::_internal_has_embedded_blob_code_start_address() const {}
inline bool InternedV8Isolate::has_embedded_blob_code_start_address() const {}
inline void InternedV8Isolate::clear_embedded_blob_code_start_address() {}
inline uint64_t InternedV8Isolate::_internal_embedded_blob_code_start_address() const {}
inline uint64_t InternedV8Isolate::embedded_blob_code_start_address() const {}
inline void InternedV8Isolate::_internal_set_embedded_blob_code_start_address(uint64_t value) {}
inline void InternedV8Isolate::set_embedded_blob_code_start_address(uint64_t value) {}

// optional uint64 embedded_blob_code_size = 6;
inline bool InternedV8Isolate::_internal_has_embedded_blob_code_size() const {}
inline bool InternedV8Isolate::has_embedded_blob_code_size() const {}
inline void InternedV8Isolate::clear_embedded_blob_code_size() {}
inline uint64_t InternedV8Isolate::_internal_embedded_blob_code_size() const {}
inline uint64_t InternedV8Isolate::embedded_blob_code_size() const {}
inline void InternedV8Isolate::_internal_set_embedded_blob_code_size(uint64_t value) {}
inline void InternedV8Isolate::set_embedded_blob_code_size(uint64_t value) {}

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

// V8JsCode

// optional uint64 v8_isolate_iid = 1;
inline bool V8JsCode::_internal_has_v8_isolate_iid() const {}
inline bool V8JsCode::has_v8_isolate_iid() const {}
inline void V8JsCode::clear_v8_isolate_iid() {}
inline uint64_t V8JsCode::_internal_v8_isolate_iid() const {}
inline uint64_t V8JsCode::v8_isolate_iid() const {}
inline void V8JsCode::_internal_set_v8_isolate_iid(uint64_t value) {}
inline void V8JsCode::set_v8_isolate_iid(uint64_t value) {}

// optional uint32 tid = 2;
inline bool V8JsCode::_internal_has_tid() const {}
inline bool V8JsCode::has_tid() const {}
inline void V8JsCode::clear_tid() {}
inline uint32_t V8JsCode::_internal_tid() const {}
inline uint32_t V8JsCode::tid() const {}
inline void V8JsCode::_internal_set_tid(uint32_t value) {}
inline void V8JsCode::set_tid(uint32_t value) {}

// optional uint64 v8_js_function_iid = 3;
inline bool V8JsCode::_internal_has_v8_js_function_iid() const {}
inline bool V8JsCode::has_v8_js_function_iid() const {}
inline void V8JsCode::clear_v8_js_function_iid() {}
inline uint64_t V8JsCode::_internal_v8_js_function_iid() const {}
inline uint64_t V8JsCode::v8_js_function_iid() const {}
inline void V8JsCode::_internal_set_v8_js_function_iid(uint64_t value) {}
inline void V8JsCode::set_v8_js_function_iid(uint64_t value) {}

// optional .perfetto.protos.V8JsCode.Tier tier = 4;
inline bool V8JsCode::_internal_has_tier() const {}
inline bool V8JsCode::has_tier() const {}
inline void V8JsCode::clear_tier() {}
inline ::perfetto::protos::V8JsCode_Tier V8JsCode::_internal_tier() const {}
inline ::perfetto::protos::V8JsCode_Tier V8JsCode::tier() const {}
inline void V8JsCode::_internal_set_tier(::perfetto::protos::V8JsCode_Tier value) {}
inline void V8JsCode::set_tier(::perfetto::protos::V8JsCode_Tier value) {}

// optional uint64 instruction_start = 5;
inline bool V8JsCode::_internal_has_instruction_start() const {}
inline bool V8JsCode::has_instruction_start() const {}
inline void V8JsCode::clear_instruction_start() {}
inline uint64_t V8JsCode::_internal_instruction_start() const {}
inline uint64_t V8JsCode::instruction_start() const {}
inline void V8JsCode::_internal_set_instruction_start(uint64_t value) {}
inline void V8JsCode::set_instruction_start(uint64_t value) {}

// optional uint64 instruction_size_bytes = 6;
inline bool V8JsCode::_internal_has_instruction_size_bytes() const {}
inline bool V8JsCode::has_instruction_size_bytes() const {}
inline void V8JsCode::clear_instruction_size_bytes() {}
inline uint64_t V8JsCode::_internal_instruction_size_bytes() const {}
inline uint64_t V8JsCode::instruction_size_bytes() const {}
inline void V8JsCode::_internal_set_instruction_size_bytes(uint64_t value) {}
inline void V8JsCode::set_instruction_size_bytes(uint64_t value) {}

// bytes machine_code = 7;
inline bool V8JsCode::_internal_has_machine_code() const {}
inline bool V8JsCode::has_machine_code() const {}
inline void V8JsCode::set_has_machine_code() {}
inline void V8JsCode::clear_machine_code() {}
inline const std::string& V8JsCode::machine_code() const {}
template <typename ArgT0, typename... ArgT>
inline void V8JsCode::set_machine_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8JsCode::mutable_machine_code() {}
inline const std::string& V8JsCode::_internal_machine_code() const {}
inline void V8JsCode::_internal_set_machine_code(const std::string& value) {}
inline std::string* V8JsCode::_internal_mutable_machine_code() {}
inline std::string* V8JsCode::release_machine_code() {}
inline void V8JsCode::set_allocated_machine_code(std::string* machine_code) {}

// bytes bytecode = 8;
inline bool V8JsCode::_internal_has_bytecode() const {}
inline bool V8JsCode::has_bytecode() const {}
inline void V8JsCode::set_has_bytecode() {}
inline void V8JsCode::clear_bytecode() {}
inline const std::string& V8JsCode::bytecode() const {}
template <typename ArgT0, typename... ArgT>
inline void V8JsCode::set_bytecode(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8JsCode::mutable_bytecode() {}
inline const std::string& V8JsCode::_internal_bytecode() const {}
inline void V8JsCode::_internal_set_bytecode(const std::string& value) {}
inline std::string* V8JsCode::_internal_mutable_bytecode() {}
inline std::string* V8JsCode::release_bytecode() {}
inline void V8JsCode::set_allocated_bytecode(std::string* bytecode) {}

inline bool V8JsCode::has_instructions() const {}
inline void V8JsCode::clear_has_instructions() {}
inline V8JsCode::InstructionsCase V8JsCode::instructions_case() const {}
// -------------------------------------------------------------------

// V8InternalCode

// optional uint64 v8_isolate_iid = 1;
inline bool V8InternalCode::_internal_has_v8_isolate_iid() const {}
inline bool V8InternalCode::has_v8_isolate_iid() const {}
inline void V8InternalCode::clear_v8_isolate_iid() {}
inline uint64_t V8InternalCode::_internal_v8_isolate_iid() const {}
inline uint64_t V8InternalCode::v8_isolate_iid() const {}
inline void V8InternalCode::_internal_set_v8_isolate_iid(uint64_t value) {}
inline void V8InternalCode::set_v8_isolate_iid(uint64_t value) {}

// optional uint32 tid = 2;
inline bool V8InternalCode::_internal_has_tid() const {}
inline bool V8InternalCode::has_tid() const {}
inline void V8InternalCode::clear_tid() {}
inline uint32_t V8InternalCode::_internal_tid() const {}
inline uint32_t V8InternalCode::tid() const {}
inline void V8InternalCode::_internal_set_tid(uint32_t value) {}
inline void V8InternalCode::set_tid(uint32_t value) {}

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

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

// optional int32 builtin_id = 5;
inline bool V8InternalCode::_internal_has_builtin_id() const {}
inline bool V8InternalCode::has_builtin_id() const {}
inline void V8InternalCode::clear_builtin_id() {}
inline int32_t V8InternalCode::_internal_builtin_id() const {}
inline int32_t V8InternalCode::builtin_id() const {}
inline void V8InternalCode::_internal_set_builtin_id(int32_t value) {}
inline void V8InternalCode::set_builtin_id(int32_t value) {}

// optional uint64 instruction_start = 6;
inline bool V8InternalCode::_internal_has_instruction_start() const {}
inline bool V8InternalCode::has_instruction_start() const {}
inline void V8InternalCode::clear_instruction_start() {}
inline uint64_t V8InternalCode::_internal_instruction_start() const {}
inline uint64_t V8InternalCode::instruction_start() const {}
inline void V8InternalCode::_internal_set_instruction_start(uint64_t value) {}
inline void V8InternalCode::set_instruction_start(uint64_t value) {}

// optional uint64 instruction_size_bytes = 7;
inline bool V8InternalCode::_internal_has_instruction_size_bytes() const {}
inline bool V8InternalCode::has_instruction_size_bytes() const {}
inline void V8InternalCode::clear_instruction_size_bytes() {}
inline uint64_t V8InternalCode::_internal_instruction_size_bytes() const {}
inline uint64_t V8InternalCode::instruction_size_bytes() const {}
inline void V8InternalCode::_internal_set_instruction_size_bytes(uint64_t value) {}
inline void V8InternalCode::set_instruction_size_bytes(uint64_t value) {}

// optional bytes machine_code = 8;
inline bool V8InternalCode::_internal_has_machine_code() const {}
inline bool V8InternalCode::has_machine_code() const {}
inline void V8InternalCode::clear_machine_code() {}
inline const std::string& V8InternalCode::machine_code() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V8InternalCode::set_machine_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8InternalCode::mutable_machine_code() {}
inline const std::string& V8InternalCode::_internal_machine_code() const {}
inline void V8InternalCode::_internal_set_machine_code(const std::string& value) {}
inline std::string* V8InternalCode::_internal_mutable_machine_code() {}
inline std::string* V8InternalCode::release_machine_code() {}
inline void V8InternalCode::set_allocated_machine_code(std::string* machine_code) {}

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

// V8WasmCode

// optional uint64 v8_isolate_iid = 1;
inline bool V8WasmCode::_internal_has_v8_isolate_iid() const {}
inline bool V8WasmCode::has_v8_isolate_iid() const {}
inline void V8WasmCode::clear_v8_isolate_iid() {}
inline uint64_t V8WasmCode::_internal_v8_isolate_iid() const {}
inline uint64_t V8WasmCode::v8_isolate_iid() const {}
inline void V8WasmCode::_internal_set_v8_isolate_iid(uint64_t value) {}
inline void V8WasmCode::set_v8_isolate_iid(uint64_t value) {}

// optional uint32 tid = 2;
inline bool V8WasmCode::_internal_has_tid() const {}
inline bool V8WasmCode::has_tid() const {}
inline void V8WasmCode::clear_tid() {}
inline uint32_t V8WasmCode::_internal_tid() const {}
inline uint32_t V8WasmCode::tid() const {}
inline void V8WasmCode::_internal_set_tid(uint32_t value) {}
inline void V8WasmCode::set_tid(uint32_t value) {}

// optional uint64 v8_wasm_script_iid = 3;
inline bool V8WasmCode::_internal_has_v8_wasm_script_iid() const {}
inline bool V8WasmCode::has_v8_wasm_script_iid() const {}
inline void V8WasmCode::clear_v8_wasm_script_iid() {}
inline uint64_t V8WasmCode::_internal_v8_wasm_script_iid() const {}
inline uint64_t V8WasmCode::v8_wasm_script_iid() const {}
inline void V8WasmCode::_internal_set_v8_wasm_script_iid(uint64_t value) {}
inline void V8WasmCode::set_v8_wasm_script_iid(uint64_t value) {}

// optional string function_name = 4;
inline bool V8WasmCode::_internal_has_function_name() const {}
inline bool V8WasmCode::has_function_name() const {}
inline void V8WasmCode::clear_function_name() {}
inline const std::string& V8WasmCode::function_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V8WasmCode::set_function_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8WasmCode::mutable_function_name() {}
inline const std::string& V8WasmCode::_internal_function_name() const {}
inline void V8WasmCode::_internal_set_function_name(const std::string& value) {}
inline std::string* V8WasmCode::_internal_mutable_function_name() {}
inline std::string* V8WasmCode::release_function_name() {}
inline void V8WasmCode::set_allocated_function_name(std::string* function_name) {}

// optional .perfetto.protos.V8WasmCode.Tier tier = 5;
inline bool V8WasmCode::_internal_has_tier() const {}
inline bool V8WasmCode::has_tier() const {}
inline void V8WasmCode::clear_tier() {}
inline ::perfetto::protos::V8WasmCode_Tier V8WasmCode::_internal_tier() const {}
inline ::perfetto::protos::V8WasmCode_Tier V8WasmCode::tier() const {}
inline void V8WasmCode::_internal_set_tier(::perfetto::protos::V8WasmCode_Tier value) {}
inline void V8WasmCode::set_tier(::perfetto::protos::V8WasmCode_Tier value) {}

// optional int32 code_offset_in_module = 6;
inline bool V8WasmCode::_internal_has_code_offset_in_module() const {}
inline bool V8WasmCode::has_code_offset_in_module() const {}
inline void V8WasmCode::clear_code_offset_in_module() {}
inline int32_t V8WasmCode::_internal_code_offset_in_module() const {}
inline int32_t V8WasmCode::code_offset_in_module() const {}
inline void V8WasmCode::_internal_set_code_offset_in_module(int32_t value) {}
inline void V8WasmCode::set_code_offset_in_module(int32_t value) {}

// optional uint64 instruction_start = 7;
inline bool V8WasmCode::_internal_has_instruction_start() const {}
inline bool V8WasmCode::has_instruction_start() const {}
inline void V8WasmCode::clear_instruction_start() {}
inline uint64_t V8WasmCode::_internal_instruction_start() const {}
inline uint64_t V8WasmCode::instruction_start() const {}
inline void V8WasmCode::_internal_set_instruction_start(uint64_t value) {}
inline void V8WasmCode::set_instruction_start(uint64_t value) {}

// optional uint64 instruction_size_bytes = 8;
inline bool V8WasmCode::_internal_has_instruction_size_bytes() const {}
inline bool V8WasmCode::has_instruction_size_bytes() const {}
inline void V8WasmCode::clear_instruction_size_bytes() {}
inline uint64_t V8WasmCode::_internal_instruction_size_bytes() const {}
inline uint64_t V8WasmCode::instruction_size_bytes() const {}
inline void V8WasmCode::_internal_set_instruction_size_bytes(uint64_t value) {}
inline void V8WasmCode::set_instruction_size_bytes(uint64_t value) {}

// optional bytes machine_code = 9;
inline bool V8WasmCode::_internal_has_machine_code() const {}
inline bool V8WasmCode::has_machine_code() const {}
inline void V8WasmCode::clear_machine_code() {}
inline const std::string& V8WasmCode::machine_code() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V8WasmCode::set_machine_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8WasmCode::mutable_machine_code() {}
inline const std::string& V8WasmCode::_internal_machine_code() const {}
inline void V8WasmCode::_internal_set_machine_code(const std::string& value) {}
inline std::string* V8WasmCode::_internal_mutable_machine_code() {}
inline std::string* V8WasmCode::release_machine_code() {}
inline void V8WasmCode::set_allocated_machine_code(std::string* machine_code) {}

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

// V8RegExpCode

// optional uint64 v8_isolate_iid = 1;
inline bool V8RegExpCode::_internal_has_v8_isolate_iid() const {}
inline bool V8RegExpCode::has_v8_isolate_iid() const {}
inline void V8RegExpCode::clear_v8_isolate_iid() {}
inline uint64_t V8RegExpCode::_internal_v8_isolate_iid() const {}
inline uint64_t V8RegExpCode::v8_isolate_iid() const {}
inline void V8RegExpCode::_internal_set_v8_isolate_iid(uint64_t value) {}
inline void V8RegExpCode::set_v8_isolate_iid(uint64_t value) {}

// optional uint32 tid = 2;
inline bool V8RegExpCode::_internal_has_tid() const {}
inline bool V8RegExpCode::has_tid() const {}
inline void V8RegExpCode::clear_tid() {}
inline uint32_t V8RegExpCode::_internal_tid() const {}
inline uint32_t V8RegExpCode::tid() const {}
inline void V8RegExpCode::_internal_set_tid(uint32_t value) {}
inline void V8RegExpCode::set_tid(uint32_t value) {}

// optional .perfetto.protos.V8String pattern = 3;
inline bool V8RegExpCode::_internal_has_pattern() const {}
inline bool V8RegExpCode::has_pattern() const {}
inline void V8RegExpCode::clear_pattern() {}
inline const ::perfetto::protos::V8String& V8RegExpCode::_internal_pattern() const {}
inline const ::perfetto::protos::V8String& V8RegExpCode::pattern() const {}
inline void V8RegExpCode::unsafe_arena_set_allocated_pattern(
    ::perfetto::protos::V8String* pattern) {}
inline ::perfetto::protos::V8String* V8RegExpCode::release_pattern() {}
inline ::perfetto::protos::V8String* V8RegExpCode::unsafe_arena_release_pattern() {}
inline ::perfetto::protos::V8String* V8RegExpCode::_internal_mutable_pattern() {}
inline ::perfetto::protos::V8String* V8RegExpCode::mutable_pattern() {}
inline void V8RegExpCode::set_allocated_pattern(::perfetto::protos::V8String* pattern) {}

// optional uint64 instruction_start = 4;
inline bool V8RegExpCode::_internal_has_instruction_start() const {}
inline bool V8RegExpCode::has_instruction_start() const {}
inline void V8RegExpCode::clear_instruction_start() {}
inline uint64_t V8RegExpCode::_internal_instruction_start() const {}
inline uint64_t V8RegExpCode::instruction_start() const {}
inline void V8RegExpCode::_internal_set_instruction_start(uint64_t value) {}
inline void V8RegExpCode::set_instruction_start(uint64_t value) {}

// optional uint64 instruction_size_bytes = 5;
inline bool V8RegExpCode::_internal_has_instruction_size_bytes() const {}
inline bool V8RegExpCode::has_instruction_size_bytes() const {}
inline void V8RegExpCode::clear_instruction_size_bytes() {}
inline uint64_t V8RegExpCode::_internal_instruction_size_bytes() const {}
inline uint64_t V8RegExpCode::instruction_size_bytes() const {}
inline void V8RegExpCode::_internal_set_instruction_size_bytes(uint64_t value) {}
inline void V8RegExpCode::set_instruction_size_bytes(uint64_t value) {}

// optional bytes machine_code = 6;
inline bool V8RegExpCode::_internal_has_machine_code() const {}
inline bool V8RegExpCode::has_machine_code() const {}
inline void V8RegExpCode::clear_machine_code() {}
inline const std::string& V8RegExpCode::machine_code() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V8RegExpCode::set_machine_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8RegExpCode::mutable_machine_code() {}
inline const std::string& V8RegExpCode::_internal_machine_code() const {}
inline void V8RegExpCode::_internal_set_machine_code(const std::string& value) {}
inline std::string* V8RegExpCode::_internal_mutable_machine_code() {}
inline std::string* V8RegExpCode::release_machine_code() {}
inline void V8RegExpCode::set_allocated_machine_code(std::string* machine_code) {}

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

// V8CodeMove

// optional uint64 isolate_iid = 1;
inline bool V8CodeMove::_internal_has_isolate_iid() const {}
inline bool V8CodeMove::has_isolate_iid() const {}
inline void V8CodeMove::clear_isolate_iid() {}
inline uint64_t V8CodeMove::_internal_isolate_iid() const {}
inline uint64_t V8CodeMove::isolate_iid() const {}
inline void V8CodeMove::_internal_set_isolate_iid(uint64_t value) {}
inline void V8CodeMove::set_isolate_iid(uint64_t value) {}

// optional uint32 tid = 2;
inline bool V8CodeMove::_internal_has_tid() const {}
inline bool V8CodeMove::has_tid() const {}
inline void V8CodeMove::clear_tid() {}
inline uint32_t V8CodeMove::_internal_tid() const {}
inline uint32_t V8CodeMove::tid() const {}
inline void V8CodeMove::_internal_set_tid(uint32_t value) {}
inline void V8CodeMove::set_tid(uint32_t value) {}

// optional uint64 from_instruction_start_address = 3;
inline bool V8CodeMove::_internal_has_from_instruction_start_address() const {}
inline bool V8CodeMove::has_from_instruction_start_address() const {}
inline void V8CodeMove::clear_from_instruction_start_address() {}
inline uint64_t V8CodeMove::_internal_from_instruction_start_address() const {}
inline uint64_t V8CodeMove::from_instruction_start_address() const {}
inline void V8CodeMove::_internal_set_from_instruction_start_address(uint64_t value) {}
inline void V8CodeMove::set_from_instruction_start_address(uint64_t value) {}

// optional uint64 to_instruction_start_address = 4;
inline bool V8CodeMove::_internal_has_to_instruction_start_address() const {}
inline bool V8CodeMove::has_to_instruction_start_address() const {}
inline void V8CodeMove::clear_to_instruction_start_address() {}
inline uint64_t V8CodeMove::_internal_to_instruction_start_address() const {}
inline uint64_t V8CodeMove::to_instruction_start_address() const {}
inline void V8CodeMove::_internal_set_to_instruction_start_address(uint64_t value) {}
inline void V8CodeMove::set_to_instruction_start_address(uint64_t value) {}

// optional uint64 instruction_size_bytes = 5;
inline bool V8CodeMove::_internal_has_instruction_size_bytes() const {}
inline bool V8CodeMove::has_instruction_size_bytes() const {}
inline void V8CodeMove::clear_instruction_size_bytes() {}
inline uint64_t V8CodeMove::_internal_instruction_size_bytes() const {}
inline uint64_t V8CodeMove::instruction_size_bytes() const {}
inline void V8CodeMove::_internal_set_instruction_size_bytes(uint64_t value) {}
inline void V8CodeMove::set_instruction_size_bytes(uint64_t value) {}

// bytes to_machine_code = 6;
inline bool V8CodeMove::_internal_has_to_machine_code() const {}
inline bool V8CodeMove::has_to_machine_code() const {}
inline void V8CodeMove::set_has_to_machine_code() {}
inline void V8CodeMove::clear_to_machine_code() {}
inline const std::string& V8CodeMove::to_machine_code() const {}
template <typename ArgT0, typename... ArgT>
inline void V8CodeMove::set_to_machine_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8CodeMove::mutable_to_machine_code() {}
inline const std::string& V8CodeMove::_internal_to_machine_code() const {}
inline void V8CodeMove::_internal_set_to_machine_code(const std::string& value) {}
inline std::string* V8CodeMove::_internal_mutable_to_machine_code() {}
inline std::string* V8CodeMove::release_to_machine_code() {}
inline void V8CodeMove::set_allocated_to_machine_code(std::string* to_machine_code) {}

// bytes to_bytecode = 7;
inline bool V8CodeMove::_internal_has_to_bytecode() const {}
inline bool V8CodeMove::has_to_bytecode() const {}
inline void V8CodeMove::set_has_to_bytecode() {}
inline void V8CodeMove::clear_to_bytecode() {}
inline const std::string& V8CodeMove::to_bytecode() const {}
template <typename ArgT0, typename... ArgT>
inline void V8CodeMove::set_to_bytecode(ArgT0&& arg0, ArgT... args) {}
inline std::string* V8CodeMove::mutable_to_bytecode() {}
inline const std::string& V8CodeMove::_internal_to_bytecode() const {}
inline void V8CodeMove::_internal_set_to_bytecode(const std::string& value) {}
inline std::string* V8CodeMove::_internal_mutable_to_bytecode() {}
inline std::string* V8CodeMove::release_to_bytecode() {}
inline void V8CodeMove::set_allocated_to_bytecode(std::string* to_bytecode) {}

inline bool V8CodeMove::has_to_instructions() const {}
inline void V8CodeMove::clear_has_to_instructions() {}
inline V8CodeMove::ToInstructionsCase V8CodeMove::to_instructions_case() const {}
// -------------------------------------------------------------------

// V8CodeDefaults

// optional uint32 tid = 1;
inline bool V8CodeDefaults::_internal_has_tid() const {}
inline bool V8CodeDefaults::has_tid() const {}
inline void V8CodeDefaults::clear_tid() {}
inline uint32_t V8CodeDefaults::_internal_tid() const {}
inline uint32_t V8CodeDefaults::tid() const {}
inline void V8CodeDefaults::_internal_set_tid(uint32_t value) {}
inline void V8CodeDefaults::set_tid(uint32_t value) {}

#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::InternedV8JsScript_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::InternedV8JsFunction_Kind> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::V8JsCode_Tier> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::V8InternalCode_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::V8WasmCode_Tier> : ::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_2ftrace_2fchrome_2fv8_2eproto