chromium/out/Default/gen/third_party/metrics_proto/system_profile.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_system_5fprofile_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_system_5fprofile_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>
#include "extension_install.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_system_5fprofile_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_system_5fprofile_2eproto {};
namespace metrics {
class SystemProfileProto;
struct SystemProfileProtoDefaultTypeInternal;
extern SystemProfileProtoDefaultTypeInternal _SystemProfileProto_default_instance_;
class SystemProfileProto_AntiVirusProduct;
struct SystemProfileProto_AntiVirusProductDefaultTypeInternal;
extern SystemProfileProto_AntiVirusProductDefaultTypeInternal _SystemProfileProto_AntiVirusProduct_default_instance_;
class SystemProfileProto_ChromeComponent;
struct SystemProfileProto_ChromeComponentDefaultTypeInternal;
extern SystemProfileProto_ChromeComponentDefaultTypeInternal _SystemProfileProto_ChromeComponent_default_instance_;
class SystemProfileProto_ClonedInstallInfo;
struct SystemProfileProto_ClonedInstallInfoDefaultTypeInternal;
extern SystemProfileProto_ClonedInstallInfoDefaultTypeInternal _SystemProfileProto_ClonedInstallInfo_default_instance_;
class SystemProfileProto_DemoModeDimensions;
struct SystemProfileProto_DemoModeDimensionsDefaultTypeInternal;
extern SystemProfileProto_DemoModeDimensionsDefaultTypeInternal _SystemProfileProto_DemoModeDimensions_default_instance_;
class SystemProfileProto_DemoModeDimensions_Retailer;
struct SystemProfileProto_DemoModeDimensions_RetailerDefaultTypeInternal;
extern SystemProfileProto_DemoModeDimensions_RetailerDefaultTypeInternal _SystemProfileProto_DemoModeDimensions_Retailer_default_instance_;
class SystemProfileProto_ExternalAccessPoint;
struct SystemProfileProto_ExternalAccessPointDefaultTypeInternal;
extern SystemProfileProto_ExternalAccessPointDefaultTypeInternal _SystemProfileProto_ExternalAccessPoint_default_instance_;
class SystemProfileProto_ExternalAudioVideoDevice;
struct SystemProfileProto_ExternalAudioVideoDeviceDefaultTypeInternal;
extern SystemProfileProto_ExternalAudioVideoDeviceDefaultTypeInternal _SystemProfileProto_ExternalAudioVideoDevice_default_instance_;
class SystemProfileProto_ExternalAudioVideoDevice_AudioDescription;
struct SystemProfileProto_ExternalAudioVideoDevice_AudioDescriptionDefaultTypeInternal;
extern SystemProfileProto_ExternalAudioVideoDevice_AudioDescriptionDefaultTypeInternal _SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_default_instance_;
class SystemProfileProto_ExternalAudioVideoDevice_CECCommand;
struct SystemProfileProto_ExternalAudioVideoDevice_CECCommandDefaultTypeInternal;
extern SystemProfileProto_ExternalAudioVideoDevice_CECCommandDefaultTypeInternal _SystemProfileProto_ExternalAudioVideoDevice_CECCommand_default_instance_;
class SystemProfileProto_FieldTrial;
struct SystemProfileProto_FieldTrialDefaultTypeInternal;
extern SystemProfileProto_FieldTrialDefaultTypeInternal _SystemProfileProto_FieldTrial_default_instance_;
class SystemProfileProto_GoogleUpdate;
struct SystemProfileProto_GoogleUpdateDefaultTypeInternal;
extern SystemProfileProto_GoogleUpdateDefaultTypeInternal _SystemProfileProto_GoogleUpdate_default_instance_;
class SystemProfileProto_GoogleUpdate_ProductInfo;
struct SystemProfileProto_GoogleUpdate_ProductInfoDefaultTypeInternal;
extern SystemProfileProto_GoogleUpdate_ProductInfoDefaultTypeInternal _SystemProfileProto_GoogleUpdate_ProductInfo_default_instance_;
class SystemProfileProto_Hardware;
struct SystemProfileProto_HardwareDefaultTypeInternal;
extern SystemProfileProto_HardwareDefaultTypeInternal _SystemProfileProto_Hardware_default_instance_;
class SystemProfileProto_Hardware_CPU;
struct SystemProfileProto_Hardware_CPUDefaultTypeInternal;
extern SystemProfileProto_Hardware_CPUDefaultTypeInternal _SystemProfileProto_Hardware_CPU_default_instance_;
class SystemProfileProto_Hardware_Drive;
struct SystemProfileProto_Hardware_DriveDefaultTypeInternal;
extern SystemProfileProto_Hardware_DriveDefaultTypeInternal _SystemProfileProto_Hardware_Drive_default_instance_;
class SystemProfileProto_Hardware_Graphics;
struct SystemProfileProto_Hardware_GraphicsDefaultTypeInternal;
extern SystemProfileProto_Hardware_GraphicsDefaultTypeInternal _SystemProfileProto_Hardware_Graphics_default_instance_;
class SystemProfileProto_Hardware_InternalStorageDevice;
struct SystemProfileProto_Hardware_InternalStorageDeviceDefaultTypeInternal;
extern SystemProfileProto_Hardware_InternalStorageDeviceDefaultTypeInternal _SystemProfileProto_Hardware_InternalStorageDevice_default_instance_;
class SystemProfileProto_Hardware_Motherboard;
struct SystemProfileProto_Hardware_MotherboardDefaultTypeInternal;
extern SystemProfileProto_Hardware_MotherboardDefaultTypeInternal _SystemProfileProto_Hardware_Motherboard_default_instance_;
class SystemProfileProto_LinkedAndroidPhoneData;
struct SystemProfileProto_LinkedAndroidPhoneDataDefaultTypeInternal;
extern SystemProfileProto_LinkedAndroidPhoneDataDefaultTypeInternal _SystemProfileProto_LinkedAndroidPhoneData_default_instance_;
class SystemProfileProto_Network;
struct SystemProfileProto_NetworkDefaultTypeInternal;
extern SystemProfileProto_NetworkDefaultTypeInternal _SystemProfileProto_Network_default_instance_;
class SystemProfileProto_OS;
struct SystemProfileProto_OSDefaultTypeInternal;
extern SystemProfileProto_OSDefaultTypeInternal _SystemProfileProto_OS_default_instance_;
class SystemProfileProto_OS_Arc;
struct SystemProfileProto_OS_ArcDefaultTypeInternal;
extern SystemProfileProto_OS_ArcDefaultTypeInternal _SystemProfileProto_OS_Arc_default_instance_;
class SystemProfileProto_Stability;
struct SystemProfileProto_StabilityDefaultTypeInternal;
extern SystemProfileProto_StabilityDefaultTypeInternal _SystemProfileProto_Stability_default_instance_;
}  // namespace metrics
PROTOBUF_NAMESPACE_OPEN
template<> ::metrics::SystemProfileProto* Arena::CreateMaybeMessage<::metrics::SystemProfileProto>(Arena*);
template<> ::metrics::SystemProfileProto_AntiVirusProduct* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_AntiVirusProduct>(Arena*);
template<> ::metrics::SystemProfileProto_ChromeComponent* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ChromeComponent>(Arena*);
template<> ::metrics::SystemProfileProto_ClonedInstallInfo* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ClonedInstallInfo>(Arena*);
template<> ::metrics::SystemProfileProto_DemoModeDimensions* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_DemoModeDimensions>(Arena*);
template<> ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_DemoModeDimensions_Retailer>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAccessPoint* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAccessPoint>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAudioVideoDevice* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAudioVideoDevice>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand>(Arena*);
template<> ::metrics::SystemProfileProto_FieldTrial* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_FieldTrial>(Arena*);
template<> ::metrics::SystemProfileProto_GoogleUpdate* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate>(Arena*);
template<> ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate_ProductInfo>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_CPU* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_CPU>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_Drive* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Drive>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_Graphics* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Graphics>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_InternalStorageDevice>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_Motherboard* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Motherboard>(Arena*);
template<> ::metrics::SystemProfileProto_LinkedAndroidPhoneData* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_LinkedAndroidPhoneData>(Arena*);
template<> ::metrics::SystemProfileProto_Network* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Network>(Arena*);
template<> ::metrics::SystemProfileProto_OS* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_OS>(Arena*);
template<> ::metrics::SystemProfileProto_OS_Arc* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_OS_Arc>(Arena*);
template<> ::metrics::SystemProfileProto_Stability* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Stability>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace metrics {

enum SystemProfileProto_OS_DarkModeState : int {};
bool SystemProfileProto_OS_DarkModeState_IsValid(int value);
constexpr SystemProfileProto_OS_DarkModeState SystemProfileProto_OS_DarkModeState_DarkModeState_MIN =;
constexpr SystemProfileProto_OS_DarkModeState SystemProfileProto_OS_DarkModeState_DarkModeState_MAX =;
constexpr int SystemProfileProto_OS_DarkModeState_DarkModeState_ARRAYSIZE =;

const std::string& SystemProfileProto_OS_DarkModeState_Name(SystemProfileProto_OS_DarkModeState value);
template<typename T>
inline const std::string& SystemProfileProto_OS_DarkModeState_Name(T enum_t_value) {}
bool SystemProfileProto_OS_DarkModeState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_OS_DarkModeState* value);
enum SystemProfileProto_OS_XdgSessionType : int {};
bool SystemProfileProto_OS_XdgSessionType_IsValid(int value);
constexpr SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS_XdgSessionType_XdgSessionType_MIN =;
constexpr SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS_XdgSessionType_XdgSessionType_MAX =;
constexpr int SystemProfileProto_OS_XdgSessionType_XdgSessionType_ARRAYSIZE =;

const std::string& SystemProfileProto_OS_XdgSessionType_Name(SystemProfileProto_OS_XdgSessionType value);
template<typename T>
inline const std::string& SystemProfileProto_OS_XdgSessionType_Name(T enum_t_value) {}
bool SystemProfileProto_OS_XdgSessionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_OS_XdgSessionType* value);
enum SystemProfileProto_OS_XdgCurrentDesktop : int {};
bool SystemProfileProto_OS_XdgCurrentDesktop_IsValid(int value);
constexpr SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MIN =;
constexpr SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MAX =;
constexpr int SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_ARRAYSIZE =;

const std::string& SystemProfileProto_OS_XdgCurrentDesktop_Name(SystemProfileProto_OS_XdgCurrentDesktop value);
template<typename T>
inline const std::string& SystemProfileProto_OS_XdgCurrentDesktop_Name(T enum_t_value) {}
bool SystemProfileProto_OS_XdgCurrentDesktop_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_OS_XdgCurrentDesktop* value);
enum SystemProfileProto_Hardware_InternalStorageDevice_Type : int {};
bool SystemProfileProto_Hardware_InternalStorageDevice_Type_IsValid(int value);
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MIN =;
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MAX =;
constexpr int SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_ARRAYSIZE =;

const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Type_Name(SystemProfileProto_Hardware_InternalStorageDevice_Type value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Type_Name(T enum_t_value) {}
bool SystemProfileProto_Hardware_InternalStorageDevice_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_InternalStorageDevice_Type* value);
enum SystemProfileProto_Hardware_InternalStorageDevice_Purpose : int {};
bool SystemProfileProto_Hardware_InternalStorageDevice_Purpose_IsValid(int value);
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MIN =;
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MAX =;
constexpr int SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_ARRAYSIZE =;

const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name(SystemProfileProto_Hardware_InternalStorageDevice_Purpose value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name(T enum_t_value) {}
bool SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_InternalStorageDevice_Purpose* value);
enum SystemProfileProto_Hardware_FormFactor : int {};
bool SystemProfileProto_Hardware_FormFactor_IsValid(int value);
constexpr SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware_FormFactor_FormFactor_MIN =;
constexpr SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware_FormFactor_FormFactor_MAX =;
constexpr int SystemProfileProto_Hardware_FormFactor_FormFactor_ARRAYSIZE =;

const std::string& SystemProfileProto_Hardware_FormFactor_Name(SystemProfileProto_Hardware_FormFactor value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_FormFactor_Name(T enum_t_value) {}
bool SystemProfileProto_Hardware_FormFactor_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_FormFactor* value);
enum SystemProfileProto_Hardware_BiosType : int {};
bool SystemProfileProto_Hardware_BiosType_IsValid(int value);
constexpr SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_BiosType_BiosType_MIN =;
constexpr SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_BiosType_BiosType_MAX =;
constexpr int SystemProfileProto_Hardware_BiosType_BiosType_ARRAYSIZE =;

const std::string& SystemProfileProto_Hardware_BiosType_Name(SystemProfileProto_Hardware_BiosType value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_BiosType_Name(T enum_t_value) {}
bool SystemProfileProto_Hardware_BiosType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_BiosType* value);
enum SystemProfileProto_Hardware_TpmType : int {};
bool SystemProfileProto_Hardware_TpmType_IsValid(int value);
constexpr SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware_TpmType_TpmType_MIN =;
constexpr SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware_TpmType_TpmType_MAX =;
constexpr int SystemProfileProto_Hardware_TpmType_TpmType_ARRAYSIZE =;

const std::string& SystemProfileProto_Hardware_TpmType_Name(SystemProfileProto_Hardware_TpmType value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_TpmType_Name(T enum_t_value) {}
bool SystemProfileProto_Hardware_TpmType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_TpmType* value);
enum SystemProfileProto_Network_ConnectionType : int {};
bool SystemProfileProto_Network_ConnectionType_IsValid(int value);
constexpr SystemProfileProto_Network_ConnectionType SystemProfileProto_Network_ConnectionType_ConnectionType_MIN =;
constexpr SystemProfileProto_Network_ConnectionType SystemProfileProto_Network_ConnectionType_ConnectionType_MAX =;
constexpr int SystemProfileProto_Network_ConnectionType_ConnectionType_ARRAYSIZE =;

const std::string& SystemProfileProto_Network_ConnectionType_Name(SystemProfileProto_Network_ConnectionType value);
template<typename T>
inline const std::string& SystemProfileProto_Network_ConnectionType_Name(T enum_t_value) {}
bool SystemProfileProto_Network_ConnectionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Network_ConnectionType* value);
enum SystemProfileProto_Network_EffectiveConnectionType : int {};
bool SystemProfileProto_Network_EffectiveConnectionType_IsValid(int value);
constexpr SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MIN =;
constexpr SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MAX =;
constexpr int SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_ARRAYSIZE =;

const std::string& SystemProfileProto_Network_EffectiveConnectionType_Name(SystemProfileProto_Network_EffectiveConnectionType value);
template<typename T>
inline const std::string& SystemProfileProto_Network_EffectiveConnectionType_Name(T enum_t_value) {}
bool SystemProfileProto_Network_EffectiveConnectionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Network_EffectiveConnectionType* value);
enum SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult : int {};
bool SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_IsValid(int value);
constexpr SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MIN =;
constexpr SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MAX =;
constexpr int SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_ARRAYSIZE =;

const std::string& SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name(SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value);
template<typename T>
inline const std::string& SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name(T enum_t_value) {}
bool SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult* value);
enum SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat : int {};
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MIN =;
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MAX =;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_ARRAYSIZE =;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name(T enum_t_value) {}
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat* value);
enum SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode : int {};
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MIN =;
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MAX =;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_ARRAYSIZE =;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name(T enum_t_value) {}
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode* value);
enum SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType : int {};
bool SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MIN =;
constexpr SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MAX =;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_ARRAYSIZE =;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name(SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name(T enum_t_value) {}
bool SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType* value);
enum SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding : int {};
bool SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MIN =;
constexpr SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MAX =;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_ARRAYSIZE =;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name(SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name(T enum_t_value) {}
bool SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding* value);
enum SystemProfileProto_DemoModeDimensions_CustomizationFacet : int {};
bool SystemProfileProto_DemoModeDimensions_CustomizationFacet_IsValid(int value);
constexpr SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MIN =;
constexpr SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MAX =;
constexpr int SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_ARRAYSIZE =;

const std::string& SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name(SystemProfileProto_DemoModeDimensions_CustomizationFacet value);
template<typename T>
inline const std::string& SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name(T enum_t_value) {}
bool SystemProfileProto_DemoModeDimensions_CustomizationFacet_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_DemoModeDimensions_CustomizationFacet* value);
enum SystemProfileProto_Channel : int {};
bool SystemProfileProto_Channel_IsValid(int value);
constexpr SystemProfileProto_Channel SystemProfileProto_Channel_Channel_MIN =;
constexpr SystemProfileProto_Channel SystemProfileProto_Channel_Channel_MAX =;
constexpr int SystemProfileProto_Channel_Channel_ARRAYSIZE =;

const std::string& SystemProfileProto_Channel_Name(SystemProfileProto_Channel value);
template<typename T>
inline const std::string& SystemProfileProto_Channel_Name(T enum_t_value) {}
bool SystemProfileProto_Channel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Channel* value);
enum SystemProfileProto_ExtensionsState : int {};
bool SystemProfileProto_ExtensionsState_IsValid(int value);
constexpr SystemProfileProto_ExtensionsState SystemProfileProto_ExtensionsState_ExtensionsState_MIN =;
constexpr SystemProfileProto_ExtensionsState SystemProfileProto_ExtensionsState_ExtensionsState_MAX =;
constexpr int SystemProfileProto_ExtensionsState_ExtensionsState_ARRAYSIZE =;

const std::string& SystemProfileProto_ExtensionsState_Name(SystemProfileProto_ExtensionsState value);
template<typename T>
inline const std::string& SystemProfileProto_ExtensionsState_Name(T enum_t_value) {}
bool SystemProfileProto_ExtensionsState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExtensionsState* value);
enum SystemProfileProto_UmaDefaultState : int {};
bool SystemProfileProto_UmaDefaultState_IsValid(int value);
constexpr SystemProfileProto_UmaDefaultState SystemProfileProto_UmaDefaultState_UmaDefaultState_MIN =;
constexpr SystemProfileProto_UmaDefaultState SystemProfileProto_UmaDefaultState_UmaDefaultState_MAX =;
constexpr int SystemProfileProto_UmaDefaultState_UmaDefaultState_ARRAYSIZE =;

const std::string& SystemProfileProto_UmaDefaultState_Name(SystemProfileProto_UmaDefaultState value);
template<typename T>
inline const std::string& SystemProfileProto_UmaDefaultState_Name(T enum_t_value) {}
bool SystemProfileProto_UmaDefaultState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_UmaDefaultState* value);
enum SystemProfileProto_AntiVirusState : int {};
bool SystemProfileProto_AntiVirusState_IsValid(int value);
constexpr SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusState_AntiVirusState_MIN =;
constexpr SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusState_AntiVirusState_MAX =;
constexpr int SystemProfileProto_AntiVirusState_AntiVirusState_ARRAYSIZE =;

const std::string& SystemProfileProto_AntiVirusState_Name(SystemProfileProto_AntiVirusState value);
template<typename T>
inline const std::string& SystemProfileProto_AntiVirusState_Name(T enum_t_value) {}
bool SystemProfileProto_AntiVirusState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_AntiVirusState* value);
enum SystemProfileProto_ComponentId : int {};
bool SystemProfileProto_ComponentId_IsValid(int value);
constexpr SystemProfileProto_ComponentId SystemProfileProto_ComponentId_ComponentId_MIN =;
constexpr SystemProfileProto_ComponentId SystemProfileProto_ComponentId_ComponentId_MAX =;
constexpr int SystemProfileProto_ComponentId_ComponentId_ARRAYSIZE =;

const std::string& SystemProfileProto_ComponentId_Name(SystemProfileProto_ComponentId value);
template<typename T>
inline const std::string& SystemProfileProto_ComponentId_Name(T enum_t_value) {}
bool SystemProfileProto_ComponentId_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ComponentId* value);
enum SystemProfileProto_AppPackageNameAllowlistFilter : int {};
bool SystemProfileProto_AppPackageNameAllowlistFilter_IsValid(int value);
constexpr SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MIN =;
constexpr SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MAX =;
constexpr int SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_ARRAYSIZE =;

const std::string& SystemProfileProto_AppPackageNameAllowlistFilter_Name(SystemProfileProto_AppPackageNameAllowlistFilter value);
template<typename T>
inline const std::string& SystemProfileProto_AppPackageNameAllowlistFilter_Name(T enum_t_value) {}
bool SystemProfileProto_AppPackageNameAllowlistFilter_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_AppPackageNameAllowlistFilter* value);
enum SystemProfileProto_ClientSideSamplingStatus : int {};
bool SystemProfileProto_ClientSideSamplingStatus_IsValid(int value);
constexpr SystemProfileProto_ClientSideSamplingStatus SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MIN =;
constexpr SystemProfileProto_ClientSideSamplingStatus SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MAX =;
constexpr int SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_ARRAYSIZE =;

const std::string& SystemProfileProto_ClientSideSamplingStatus_Name(SystemProfileProto_ClientSideSamplingStatus value);
template<typename T>
inline const std::string& SystemProfileProto_ClientSideSamplingStatus_Name(T enum_t_value) {}
bool SystemProfileProto_ClientSideSamplingStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ClientSideSamplingStatus* value);
enum SystemProfileProto_MetricsFilteringStatus : int {};
bool SystemProfileProto_MetricsFilteringStatus_IsValid(int value);
constexpr SystemProfileProto_MetricsFilteringStatus SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MIN =;
constexpr SystemProfileProto_MetricsFilteringStatus SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MAX =;
constexpr int SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_ARRAYSIZE =;

const std::string& SystemProfileProto_MetricsFilteringStatus_Name(SystemProfileProto_MetricsFilteringStatus value);
template<typename T>
inline const std::string& SystemProfileProto_MetricsFilteringStatus_Name(T enum_t_value) {}
bool SystemProfileProto_MetricsFilteringStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_MetricsFilteringStatus* value);
enum SystemProfileProto_InstallerPackage : int {};
bool SystemProfileProto_InstallerPackage_IsValid(int value);
constexpr SystemProfileProto_InstallerPackage SystemProfileProto_InstallerPackage_InstallerPackage_MIN =;
constexpr SystemProfileProto_InstallerPackage SystemProfileProto_InstallerPackage_InstallerPackage_MAX =;
constexpr int SystemProfileProto_InstallerPackage_InstallerPackage_ARRAYSIZE =;

const std::string& SystemProfileProto_InstallerPackage_Name(SystemProfileProto_InstallerPackage value);
template<typename T>
inline const std::string& SystemProfileProto_InstallerPackage_Name(T enum_t_value) {}
bool SystemProfileProto_InstallerPackage_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_InstallerPackage* value);
enum SystemProfileProto_LTSChannel : int {};
bool SystemProfileProto_LTSChannel_IsValid(int value);
constexpr SystemProfileProto_LTSChannel SystemProfileProto_LTSChannel_LTSChannel_MIN =;
constexpr SystemProfileProto_LTSChannel SystemProfileProto_LTSChannel_LTSChannel_MAX =;
constexpr int SystemProfileProto_LTSChannel_LTSChannel_ARRAYSIZE =;

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

class SystemProfileProto_ClonedInstallInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ClonedInstallInfo) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_OS_Arc final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.OS.Arc) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_OS final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.OS) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_CPU final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.CPU) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_Motherboard final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.Motherboard) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_Graphics final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.Graphics) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_InternalStorageDevice final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.InternalStorageDevice) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_Drive final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.Drive) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Network final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Network) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_GoogleUpdate_ProductInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.GoogleUpdate.ProductInfo) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_GoogleUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.GoogleUpdate) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_Stability final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Stability) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_FieldTrial final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.FieldTrial) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAudioVideoDevice_AudioDescription final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAudioVideoDevice_CECCommand final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAudioVideoDevice final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAudioVideoDevice) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAccessPoint final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAccessPoint) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_AntiVirusProduct final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.AntiVirusProduct) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_ChromeComponent final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ChromeComponent) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_LinkedAndroidPhoneData final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.LinkedAndroidPhoneData) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_DemoModeDimensions_Retailer final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.DemoModeDimensions.Retailer) */ {};
// -------------------------------------------------------------------

class SystemProfileProto_DemoModeDimensions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.DemoModeDimensions) */ {};
// -------------------------------------------------------------------

class SystemProfileProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto) */ {};
// ===================================================================


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

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

// optional int64 last_timestamp = 1;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_last_timestamp() const {}
inline bool SystemProfileProto_ClonedInstallInfo::has_last_timestamp() const {}
inline void SystemProfileProto_ClonedInstallInfo::clear_last_timestamp() {}
inline int64_t SystemProfileProto_ClonedInstallInfo::_internal_last_timestamp() const {}
inline int64_t SystemProfileProto_ClonedInstallInfo::last_timestamp() const {}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_last_timestamp(int64_t value) {}
inline void SystemProfileProto_ClonedInstallInfo::set_last_timestamp(int64_t value) {}

// optional fixed64 cloned_from_client_id = 2;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_cloned_from_client_id() const {}
inline bool SystemProfileProto_ClonedInstallInfo::has_cloned_from_client_id() const {}
inline void SystemProfileProto_ClonedInstallInfo::clear_cloned_from_client_id() {}
inline uint64_t SystemProfileProto_ClonedInstallInfo::_internal_cloned_from_client_id() const {}
inline uint64_t SystemProfileProto_ClonedInstallInfo::cloned_from_client_id() const {}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_cloned_from_client_id(uint64_t value) {}
inline void SystemProfileProto_ClonedInstallInfo::set_cloned_from_client_id(uint64_t value) {}

// optional int64 first_timestamp = 3;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_first_timestamp() const {}
inline bool SystemProfileProto_ClonedInstallInfo::has_first_timestamp() const {}
inline void SystemProfileProto_ClonedInstallInfo::clear_first_timestamp() {}
inline int64_t SystemProfileProto_ClonedInstallInfo::_internal_first_timestamp() const {}
inline int64_t SystemProfileProto_ClonedInstallInfo::first_timestamp() const {}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_first_timestamp(int64_t value) {}
inline void SystemProfileProto_ClonedInstallInfo::set_first_timestamp(int64_t value) {}

// optional int32 count = 4;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_count() const {}
inline bool SystemProfileProto_ClonedInstallInfo::has_count() const {}
inline void SystemProfileProto_ClonedInstallInfo::clear_count() {}
inline int32_t SystemProfileProto_ClonedInstallInfo::_internal_count() const {}
inline int32_t SystemProfileProto_ClonedInstallInfo::count() const {}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_count(int32_t value) {}
inline void SystemProfileProto_ClonedInstallInfo::set_count(int32_t value) {}

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

// SystemProfileProto_OS_Arc

// optional string release = 1;
inline bool SystemProfileProto_OS_Arc::_internal_has_release() const {}
inline bool SystemProfileProto_OS_Arc::has_release() const {}
inline void SystemProfileProto_OS_Arc::clear_release() {}
inline const std::string& SystemProfileProto_OS_Arc::release() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS_Arc::set_release(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_OS_Arc::mutable_release() {}
inline const std::string& SystemProfileProto_OS_Arc::_internal_release() const {}
inline void SystemProfileProto_OS_Arc::_internal_set_release(const std::string& value) {}
inline std::string* SystemProfileProto_OS_Arc::_internal_mutable_release() {}
inline std::string* SystemProfileProto_OS_Arc::release_release() {}
inline void SystemProfileProto_OS_Arc::set_allocated_release(std::string* release) {}

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

// SystemProfileProto_OS

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

// optional string version = 2;
inline bool SystemProfileProto_OS::_internal_has_version() const {}
inline bool SystemProfileProto_OS::has_version() const {}
inline void SystemProfileProto_OS::clear_version() {}
inline const std::string& SystemProfileProto_OS::version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_OS::mutable_version() {}
inline const std::string& SystemProfileProto_OS::_internal_version() const {}
inline void SystemProfileProto_OS::_internal_set_version(const std::string& value) {}
inline std::string* SystemProfileProto_OS::_internal_mutable_version() {}
inline std::string* SystemProfileProto_OS::release_version() {}
inline void SystemProfileProto_OS::set_allocated_version(std::string* version) {}

// optional string build_fingerprint = 3;
inline bool SystemProfileProto_OS::_internal_has_build_fingerprint() const {}
inline bool SystemProfileProto_OS::has_build_fingerprint() const {}
inline void SystemProfileProto_OS::clear_build_fingerprint() {}
inline const std::string& SystemProfileProto_OS::build_fingerprint() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_build_fingerprint(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_OS::mutable_build_fingerprint() {}
inline const std::string& SystemProfileProto_OS::_internal_build_fingerprint() const {}
inline void SystemProfileProto_OS::_internal_set_build_fingerprint(const std::string& value) {}
inline std::string* SystemProfileProto_OS::_internal_mutable_build_fingerprint() {}
inline std::string* SystemProfileProto_OS::release_build_fingerprint() {}
inline void SystemProfileProto_OS::set_allocated_build_fingerprint(std::string* build_fingerprint) {}

// optional string build_number = 5;
inline bool SystemProfileProto_OS::_internal_has_build_number() const {}
inline bool SystemProfileProto_OS::has_build_number() const {}
inline void SystemProfileProto_OS::clear_build_number() {}
inline const std::string& SystemProfileProto_OS::build_number() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_build_number(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_OS::mutable_build_number() {}
inline const std::string& SystemProfileProto_OS::_internal_build_number() const {}
inline void SystemProfileProto_OS::_internal_set_build_number(const std::string& value) {}
inline std::string* SystemProfileProto_OS::_internal_mutable_build_number() {}
inline std::string* SystemProfileProto_OS::release_build_number() {}
inline void SystemProfileProto_OS::set_allocated_build_number(std::string* build_number) {}

// optional string kernel_version = 6;
inline bool SystemProfileProto_OS::_internal_has_kernel_version() const {}
inline bool SystemProfileProto_OS::has_kernel_version() const {}
inline void SystemProfileProto_OS::clear_kernel_version() {}
inline const std::string& SystemProfileProto_OS::kernel_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_kernel_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_OS::mutable_kernel_version() {}
inline const std::string& SystemProfileProto_OS::_internal_kernel_version() const {}
inline void SystemProfileProto_OS::_internal_set_kernel_version(const std::string& value) {}
inline std::string* SystemProfileProto_OS::_internal_mutable_kernel_version() {}
inline std::string* SystemProfileProto_OS::release_kernel_version() {}
inline void SystemProfileProto_OS::set_allocated_kernel_version(std::string* kernel_version) {}

// optional .metrics.SystemProfileProto.OS.Arc arc = 7;
inline bool SystemProfileProto_OS::_internal_has_arc() const {}
inline bool SystemProfileProto_OS::has_arc() const {}
inline void SystemProfileProto_OS::clear_arc() {}
inline const ::metrics::SystemProfileProto_OS_Arc& SystemProfileProto_OS::_internal_arc() const {}
inline const ::metrics::SystemProfileProto_OS_Arc& SystemProfileProto_OS::arc() const {}
inline void SystemProfileProto_OS::unsafe_arena_set_allocated_arc(
    ::metrics::SystemProfileProto_OS_Arc* arc) {}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::release_arc() {}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::unsafe_arena_release_arc() {}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::_internal_mutable_arc() {}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::mutable_arc() {}
inline void SystemProfileProto_OS::set_allocated_arc(::metrics::SystemProfileProto_OS_Arc* arc) {}

// optional .metrics.SystemProfileProto.OS.DarkModeState dark_mode_state = 8 [default = UNKNOWN];
inline bool SystemProfileProto_OS::_internal_has_dark_mode_state() const {}
inline bool SystemProfileProto_OS::has_dark_mode_state() const {}
inline void SystemProfileProto_OS::clear_dark_mode_state() {}
inline ::metrics::SystemProfileProto_OS_DarkModeState SystemProfileProto_OS::_internal_dark_mode_state() const {}
inline ::metrics::SystemProfileProto_OS_DarkModeState SystemProfileProto_OS::dark_mode_state() const {}
inline void SystemProfileProto_OS::_internal_set_dark_mode_state(::metrics::SystemProfileProto_OS_DarkModeState value) {}
inline void SystemProfileProto_OS::set_dark_mode_state(::metrics::SystemProfileProto_OS_DarkModeState value) {}

// optional .metrics.SystemProfileProto.OS.XdgSessionType xdg_session_type = 9;
inline bool SystemProfileProto_OS::_internal_has_xdg_session_type() const {}
inline bool SystemProfileProto_OS::has_xdg_session_type() const {}
inline void SystemProfileProto_OS::clear_xdg_session_type() {}
inline ::metrics::SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS::_internal_xdg_session_type() const {}
inline ::metrics::SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS::xdg_session_type() const {}
inline void SystemProfileProto_OS::_internal_set_xdg_session_type(::metrics::SystemProfileProto_OS_XdgSessionType value) {}
inline void SystemProfileProto_OS::set_xdg_session_type(::metrics::SystemProfileProto_OS_XdgSessionType value) {}

// optional .metrics.SystemProfileProto.OS.XdgCurrentDesktop xdg_current_desktop = 10;
inline bool SystemProfileProto_OS::_internal_has_xdg_current_desktop() const {}
inline bool SystemProfileProto_OS::has_xdg_current_desktop() const {}
inline void SystemProfileProto_OS::clear_xdg_current_desktop() {}
inline ::metrics::SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS::_internal_xdg_current_desktop() const {}
inline ::metrics::SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS::xdg_current_desktop() const {}
inline void SystemProfileProto_OS::_internal_set_xdg_current_desktop(::metrics::SystemProfileProto_OS_XdgCurrentDesktop value) {}
inline void SystemProfileProto_OS::set_xdg_current_desktop(::metrics::SystemProfileProto_OS_XdgCurrentDesktop value) {}

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

// SystemProfileProto_Hardware_CPU

// optional string vendor_name = 1;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_vendor_name() const {}
inline bool SystemProfileProto_Hardware_CPU::has_vendor_name() const {}
inline void SystemProfileProto_Hardware_CPU::clear_vendor_name() {}
inline const std::string& SystemProfileProto_Hardware_CPU::vendor_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_CPU::set_vendor_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_CPU::mutable_vendor_name() {}
inline const std::string& SystemProfileProto_Hardware_CPU::_internal_vendor_name() const {}
inline void SystemProfileProto_Hardware_CPU::_internal_set_vendor_name(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_CPU::_internal_mutable_vendor_name() {}
inline std::string* SystemProfileProto_Hardware_CPU::release_vendor_name() {}
inline void SystemProfileProto_Hardware_CPU::set_allocated_vendor_name(std::string* vendor_name) {}

// optional uint32 signature = 2;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_signature() const {}
inline bool SystemProfileProto_Hardware_CPU::has_signature() const {}
inline void SystemProfileProto_Hardware_CPU::clear_signature() {}
inline uint32_t SystemProfileProto_Hardware_CPU::_internal_signature() const {}
inline uint32_t SystemProfileProto_Hardware_CPU::signature() const {}
inline void SystemProfileProto_Hardware_CPU::_internal_set_signature(uint32_t value) {}
inline void SystemProfileProto_Hardware_CPU::set_signature(uint32_t value) {}

// optional uint32 num_cores = 3;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_num_cores() const {}
inline bool SystemProfileProto_Hardware_CPU::has_num_cores() const {}
inline void SystemProfileProto_Hardware_CPU::clear_num_cores() {}
inline uint32_t SystemProfileProto_Hardware_CPU::_internal_num_cores() const {}
inline uint32_t SystemProfileProto_Hardware_CPU::num_cores() const {}
inline void SystemProfileProto_Hardware_CPU::_internal_set_num_cores(uint32_t value) {}
inline void SystemProfileProto_Hardware_CPU::set_num_cores(uint32_t value) {}

// optional bool is_hypervisor = 4;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_is_hypervisor() const {}
inline bool SystemProfileProto_Hardware_CPU::has_is_hypervisor() const {}
inline void SystemProfileProto_Hardware_CPU::clear_is_hypervisor() {}
inline bool SystemProfileProto_Hardware_CPU::_internal_is_hypervisor() const {}
inline bool SystemProfileProto_Hardware_CPU::is_hypervisor() const {}
inline void SystemProfileProto_Hardware_CPU::_internal_set_is_hypervisor(bool value) {}
inline void SystemProfileProto_Hardware_CPU::set_is_hypervisor(bool value) {}

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

// SystemProfileProto_Hardware_Motherboard

// optional string manufacturer = 1;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_manufacturer() const {}
inline bool SystemProfileProto_Hardware_Motherboard::has_manufacturer() const {}
inline void SystemProfileProto_Hardware_Motherboard::clear_manufacturer() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::manufacturer() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_manufacturer(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_manufacturer() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_manufacturer() const {}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_manufacturer(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_manufacturer() {}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_manufacturer() {}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_manufacturer(std::string* manufacturer) {}

// optional string model = 2;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_model() const {}
inline bool SystemProfileProto_Hardware_Motherboard::has_model() const {}
inline void SystemProfileProto_Hardware_Motherboard::clear_model() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::model() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_model(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_model() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_model() const {}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_model(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_model() {}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_model() {}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_model(std::string* model) {}

// optional string bios_manufacturer = 3;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_bios_manufacturer() const {}
inline bool SystemProfileProto_Hardware_Motherboard::has_bios_manufacturer() const {}
inline void SystemProfileProto_Hardware_Motherboard::clear_bios_manufacturer() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::bios_manufacturer() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_bios_manufacturer(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_bios_manufacturer() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_bios_manufacturer() const {}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_bios_manufacturer(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_bios_manufacturer() {}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_bios_manufacturer() {}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_bios_manufacturer(std::string* bios_manufacturer) {}

// optional string bios_version = 4;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_bios_version() const {}
inline bool SystemProfileProto_Hardware_Motherboard::has_bios_version() const {}
inline void SystemProfileProto_Hardware_Motherboard::clear_bios_version() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::bios_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_bios_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_bios_version() {}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_bios_version() const {}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_bios_version(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_bios_version() {}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_bios_version() {}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_bios_version(std::string* bios_version) {}

// optional .metrics.SystemProfileProto.Hardware.BiosType bios_type = 5;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_bios_type() const {}
inline bool SystemProfileProto_Hardware_Motherboard::has_bios_type() const {}
inline void SystemProfileProto_Hardware_Motherboard::clear_bios_type() {}
inline ::metrics::SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_Motherboard::_internal_bios_type() const {}
inline ::metrics::SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_Motherboard::bios_type() const {}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_bios_type(::metrics::SystemProfileProto_Hardware_BiosType value) {}
inline void SystemProfileProto_Hardware_Motherboard::set_bios_type(::metrics::SystemProfileProto_Hardware_BiosType value) {}

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

// SystemProfileProto_Hardware_Graphics

// optional uint32 vendor_id = 1;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_vendor_id() const {}
inline bool SystemProfileProto_Hardware_Graphics::has_vendor_id() const {}
inline void SystemProfileProto_Hardware_Graphics::clear_vendor_id() {}
inline uint32_t SystemProfileProto_Hardware_Graphics::_internal_vendor_id() const {}
inline uint32_t SystemProfileProto_Hardware_Graphics::vendor_id() const {}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_vendor_id(uint32_t value) {}
inline void SystemProfileProto_Hardware_Graphics::set_vendor_id(uint32_t value) {}

// optional uint32 device_id = 2;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_device_id() const {}
inline bool SystemProfileProto_Hardware_Graphics::has_device_id() const {}
inline void SystemProfileProto_Hardware_Graphics::clear_device_id() {}
inline uint32_t SystemProfileProto_Hardware_Graphics::_internal_device_id() const {}
inline uint32_t SystemProfileProto_Hardware_Graphics::device_id() const {}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_device_id(uint32_t value) {}
inline void SystemProfileProto_Hardware_Graphics::set_device_id(uint32_t value) {}

// optional string driver_version = 3;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_driver_version() const {}
inline bool SystemProfileProto_Hardware_Graphics::has_driver_version() const {}
inline void SystemProfileProto_Hardware_Graphics::clear_driver_version() {}
inline const std::string& SystemProfileProto_Hardware_Graphics::driver_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Graphics::set_driver_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Graphics::mutable_driver_version() {}
inline const std::string& SystemProfileProto_Hardware_Graphics::_internal_driver_version() const {}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_driver_version(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Graphics::_internal_mutable_driver_version() {}
inline std::string* SystemProfileProto_Hardware_Graphics::release_driver_version() {}
inline void SystemProfileProto_Hardware_Graphics::set_allocated_driver_version(std::string* driver_version) {}

// optional string gl_vendor = 6;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_gl_vendor() const {}
inline bool SystemProfileProto_Hardware_Graphics::has_gl_vendor() const {}
inline void SystemProfileProto_Hardware_Graphics::clear_gl_vendor() {}
inline const std::string& SystemProfileProto_Hardware_Graphics::gl_vendor() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Graphics::set_gl_vendor(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Graphics::mutable_gl_vendor() {}
inline const std::string& SystemProfileProto_Hardware_Graphics::_internal_gl_vendor() const {}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_gl_vendor(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Graphics::_internal_mutable_gl_vendor() {}
inline std::string* SystemProfileProto_Hardware_Graphics::release_gl_vendor() {}
inline void SystemProfileProto_Hardware_Graphics::set_allocated_gl_vendor(std::string* gl_vendor) {}

// optional string gl_renderer = 7;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_gl_renderer() const {}
inline bool SystemProfileProto_Hardware_Graphics::has_gl_renderer() const {}
inline void SystemProfileProto_Hardware_Graphics::clear_gl_renderer() {}
inline const std::string& SystemProfileProto_Hardware_Graphics::gl_renderer() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Graphics::set_gl_renderer(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_Graphics::mutable_gl_renderer() {}
inline const std::string& SystemProfileProto_Hardware_Graphics::_internal_gl_renderer() const {}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_gl_renderer(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_Graphics::_internal_mutable_gl_renderer() {}
inline std::string* SystemProfileProto_Hardware_Graphics::release_gl_renderer() {}
inline void SystemProfileProto_Hardware_Graphics::set_allocated_gl_renderer(std::string* gl_renderer) {}

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

// SystemProfileProto_Hardware_InternalStorageDevice

// optional uint32 vendor_id = 1;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_vendor_id() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_vendor_id() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_vendor_id() {}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_vendor_id() const {}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::vendor_id() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_vendor_id(uint32_t value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_vendor_id(uint32_t value) {}

// optional uint64 product_id = 2;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_product_id() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_product_id() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_product_id() {}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_product_id() const {}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::product_id() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_product_id(uint64_t value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_product_id(uint64_t value) {}

// optional uint32 revision = 3;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_revision() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_revision() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_revision() {}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_revision() const {}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::revision() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_revision(uint32_t value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_revision(uint32_t value) {}

// optional string model = 4;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_model() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_model() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_model() {}
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice::model() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_InternalStorageDevice::set_model(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware_InternalStorageDevice::mutable_model() {}
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice::_internal_model() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_model(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware_InternalStorageDevice::_internal_mutable_model() {}
inline std::string* SystemProfileProto_Hardware_InternalStorageDevice::release_model() {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_allocated_model(std::string* model) {}

// optional uint32 size_mb = 5;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_size_mb() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_size_mb() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_size_mb() {}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_size_mb() const {}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::size_mb() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_size_mb(uint32_t value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_size_mb(uint32_t value) {}

// optional uint64 firmware_version = 6;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_firmware_version() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_firmware_version() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_firmware_version() {}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_firmware_version() const {}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::firmware_version() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_firmware_version(uint64_t value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_firmware_version(uint64_t value) {}

// optional .metrics.SystemProfileProto.Hardware.InternalStorageDevice.Type type = 7;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_type() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_type() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_type() {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice::_internal_type() const {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice::type() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_type(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_type(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type value) {}

// optional .metrics.SystemProfileProto.Hardware.InternalStorageDevice.Purpose purpose = 8;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_purpose() const {}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_purpose() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_purpose() {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice::_internal_purpose() const {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice::purpose() const {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_purpose(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose value) {}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_purpose(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose value) {}

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

// SystemProfileProto_Hardware_Drive

// optional bool has_seek_penalty = 1;
inline bool SystemProfileProto_Hardware_Drive::_internal_has_has_seek_penalty() const {}
inline bool SystemProfileProto_Hardware_Drive::has_has_seek_penalty() const {}
inline void SystemProfileProto_Hardware_Drive::clear_has_seek_penalty() {}
inline bool SystemProfileProto_Hardware_Drive::_internal_has_seek_penalty() const {}
inline bool SystemProfileProto_Hardware_Drive::has_seek_penalty() const {}
inline void SystemProfileProto_Hardware_Drive::_internal_set_has_seek_penalty(bool value) {}
inline void SystemProfileProto_Hardware_Drive::set_has_seek_penalty(bool value) {}

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

// SystemProfileProto_Hardware

// optional string cpu_architecture = 1;
inline bool SystemProfileProto_Hardware::_internal_has_cpu_architecture() const {}
inline bool SystemProfileProto_Hardware::has_cpu_architecture() const {}
inline void SystemProfileProto_Hardware::clear_cpu_architecture() {}
inline const std::string& SystemProfileProto_Hardware::cpu_architecture() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_cpu_architecture(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware::mutable_cpu_architecture() {}
inline const std::string& SystemProfileProto_Hardware::_internal_cpu_architecture() const {}
inline void SystemProfileProto_Hardware::_internal_set_cpu_architecture(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_cpu_architecture() {}
inline std::string* SystemProfileProto_Hardware::release_cpu_architecture() {}
inline void SystemProfileProto_Hardware::set_allocated_cpu_architecture(std::string* cpu_architecture) {}

// optional string app_cpu_architecture = 21;
inline bool SystemProfileProto_Hardware::_internal_has_app_cpu_architecture() const {}
inline bool SystemProfileProto_Hardware::has_app_cpu_architecture() const {}
inline void SystemProfileProto_Hardware::clear_app_cpu_architecture() {}
inline const std::string& SystemProfileProto_Hardware::app_cpu_architecture() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_app_cpu_architecture(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware::mutable_app_cpu_architecture() {}
inline const std::string& SystemProfileProto_Hardware::_internal_app_cpu_architecture() const {}
inline void SystemProfileProto_Hardware::_internal_set_app_cpu_architecture(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_app_cpu_architecture() {}
inline std::string* SystemProfileProto_Hardware::release_app_cpu_architecture() {}
inline void SystemProfileProto_Hardware::set_allocated_app_cpu_architecture(std::string* app_cpu_architecture) {}

// optional int64 system_ram_mb = 2;
inline bool SystemProfileProto_Hardware::_internal_has_system_ram_mb() const {}
inline bool SystemProfileProto_Hardware::has_system_ram_mb() const {}
inline void SystemProfileProto_Hardware::clear_system_ram_mb() {}
inline int64_t SystemProfileProto_Hardware::_internal_system_ram_mb() const {}
inline int64_t SystemProfileProto_Hardware::system_ram_mb() const {}
inline void SystemProfileProto_Hardware::_internal_set_system_ram_mb(int64_t value) {}
inline void SystemProfileProto_Hardware::set_system_ram_mb(int64_t value) {}

// optional int64 dll_base = 3;
inline bool SystemProfileProto_Hardware::_internal_has_dll_base() const {}
inline bool SystemProfileProto_Hardware::has_dll_base() const {}
inline void SystemProfileProto_Hardware::clear_dll_base() {}
inline int64_t SystemProfileProto_Hardware::_internal_dll_base() const {}
inline int64_t SystemProfileProto_Hardware::dll_base() const {}
inline void SystemProfileProto_Hardware::_internal_set_dll_base(int64_t value) {}
inline void SystemProfileProto_Hardware::set_dll_base(int64_t value) {}

// optional string hardware_class = 4;
inline bool SystemProfileProto_Hardware::_internal_has_hardware_class() const {}
inline bool SystemProfileProto_Hardware::has_hardware_class() const {}
inline void SystemProfileProto_Hardware::clear_hardware_class() {}
inline const std::string& SystemProfileProto_Hardware::hardware_class() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_hardware_class(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware::mutable_hardware_class() {}
inline const std::string& SystemProfileProto_Hardware::_internal_hardware_class() const {}
inline void SystemProfileProto_Hardware::_internal_set_hardware_class(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_hardware_class() {}
inline std::string* SystemProfileProto_Hardware::release_hardware_class() {}
inline void SystemProfileProto_Hardware::set_allocated_hardware_class(std::string* hardware_class) {}

// optional string full_hardware_class = 18;
inline bool SystemProfileProto_Hardware::_internal_has_full_hardware_class() const {}
inline bool SystemProfileProto_Hardware::has_full_hardware_class() const {}
inline void SystemProfileProto_Hardware::clear_full_hardware_class() {}
inline const std::string& SystemProfileProto_Hardware::full_hardware_class() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_full_hardware_class(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware::mutable_full_hardware_class() {}
inline const std::string& SystemProfileProto_Hardware::_internal_full_hardware_class() const {}
inline void SystemProfileProto_Hardware::_internal_set_full_hardware_class(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_full_hardware_class() {}
inline std::string* SystemProfileProto_Hardware::release_full_hardware_class() {}
inline void SystemProfileProto_Hardware::set_allocated_full_hardware_class(std::string* full_hardware_class) {}

// optional string cellular_device_variant = 24;
inline bool SystemProfileProto_Hardware::_internal_has_cellular_device_variant() const {}
inline bool SystemProfileProto_Hardware::has_cellular_device_variant() const {}
inline void SystemProfileProto_Hardware::clear_cellular_device_variant() {}
inline const std::string& SystemProfileProto_Hardware::cellular_device_variant() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_cellular_device_variant(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware::mutable_cellular_device_variant() {}
inline const std::string& SystemProfileProto_Hardware::_internal_cellular_device_variant() const {}
inline void SystemProfileProto_Hardware::_internal_set_cellular_device_variant(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_cellular_device_variant() {}
inline std::string* SystemProfileProto_Hardware::release_cellular_device_variant() {}
inline void SystemProfileProto_Hardware::set_allocated_cellular_device_variant(std::string* cellular_device_variant) {}

// optional int32 screen_count = 5;
inline bool SystemProfileProto_Hardware::_internal_has_screen_count() const {}
inline bool SystemProfileProto_Hardware::has_screen_count() const {}
inline void SystemProfileProto_Hardware::clear_screen_count() {}
inline int32_t SystemProfileProto_Hardware::_internal_screen_count() const {}
inline int32_t SystemProfileProto_Hardware::screen_count() const {}
inline void SystemProfileProto_Hardware::_internal_set_screen_count(int32_t value) {}
inline void SystemProfileProto_Hardware::set_screen_count(int32_t value) {}

// optional int32 primary_screen_width = 6;
inline bool SystemProfileProto_Hardware::_internal_has_primary_screen_width() const {}
inline bool SystemProfileProto_Hardware::has_primary_screen_width() const {}
inline void SystemProfileProto_Hardware::clear_primary_screen_width() {}
inline int32_t SystemProfileProto_Hardware::_internal_primary_screen_width() const {}
inline int32_t SystemProfileProto_Hardware::primary_screen_width() const {}
inline void SystemProfileProto_Hardware::_internal_set_primary_screen_width(int32_t value) {}
inline void SystemProfileProto_Hardware::set_primary_screen_width(int32_t value) {}

// optional int32 primary_screen_height = 7;
inline bool SystemProfileProto_Hardware::_internal_has_primary_screen_height() const {}
inline bool SystemProfileProto_Hardware::has_primary_screen_height() const {}
inline void SystemProfileProto_Hardware::clear_primary_screen_height() {}
inline int32_t SystemProfileProto_Hardware::_internal_primary_screen_height() const {}
inline int32_t SystemProfileProto_Hardware::primary_screen_height() const {}
inline void SystemProfileProto_Hardware::_internal_set_primary_screen_height(int32_t value) {}
inline void SystemProfileProto_Hardware::set_primary_screen_height(int32_t value) {}

// optional float primary_screen_scale_factor = 12;
inline bool SystemProfileProto_Hardware::_internal_has_primary_screen_scale_factor() const {}
inline bool SystemProfileProto_Hardware::has_primary_screen_scale_factor() const {}
inline void SystemProfileProto_Hardware::clear_primary_screen_scale_factor() {}
inline float SystemProfileProto_Hardware::_internal_primary_screen_scale_factor() const {}
inline float SystemProfileProto_Hardware::primary_screen_scale_factor() const {}
inline void SystemProfileProto_Hardware::_internal_set_primary_screen_scale_factor(float value) {}
inline void SystemProfileProto_Hardware::set_primary_screen_scale_factor(float value) {}

// optional float max_dpi_x = 9;
inline bool SystemProfileProto_Hardware::_internal_has_max_dpi_x() const {}
inline bool SystemProfileProto_Hardware::has_max_dpi_x() const {}
inline void SystemProfileProto_Hardware::clear_max_dpi_x() {}
inline float SystemProfileProto_Hardware::_internal_max_dpi_x() const {}
inline float SystemProfileProto_Hardware::max_dpi_x() const {}
inline void SystemProfileProto_Hardware::_internal_set_max_dpi_x(float value) {}
inline void SystemProfileProto_Hardware::set_max_dpi_x(float value) {}

// optional float max_dpi_y = 10;
inline bool SystemProfileProto_Hardware::_internal_has_max_dpi_y() const {}
inline bool SystemProfileProto_Hardware::has_max_dpi_y() const {}
inline void SystemProfileProto_Hardware::clear_max_dpi_y() {}
inline float SystemProfileProto_Hardware::_internal_max_dpi_y() const {}
inline float SystemProfileProto_Hardware::max_dpi_y() const {}
inline void SystemProfileProto_Hardware::_internal_set_max_dpi_y(float value) {}
inline void SystemProfileProto_Hardware::set_max_dpi_y(float value) {}

// optional .metrics.SystemProfileProto.Hardware.FormFactor form_factor = 22;
inline bool SystemProfileProto_Hardware::_internal_has_form_factor() const {}
inline bool SystemProfileProto_Hardware::has_form_factor() const {}
inline void SystemProfileProto_Hardware::clear_form_factor() {}
inline ::metrics::SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware::_internal_form_factor() const {}
inline ::metrics::SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware::form_factor() const {}
inline void SystemProfileProto_Hardware::_internal_set_form_factor(::metrics::SystemProfileProto_Hardware_FormFactor value) {}
inline void SystemProfileProto_Hardware::set_form_factor(::metrics::SystemProfileProto_Hardware_FormFactor value) {}

// optional .metrics.SystemProfileProto.Hardware.CPU cpu = 13;
inline bool SystemProfileProto_Hardware::_internal_has_cpu() const {}
inline bool SystemProfileProto_Hardware::has_cpu() const {}
inline void SystemProfileProto_Hardware::clear_cpu() {}
inline const ::metrics::SystemProfileProto_Hardware_CPU& SystemProfileProto_Hardware::_internal_cpu() const {}
inline const ::metrics::SystemProfileProto_Hardware_CPU& SystemProfileProto_Hardware::cpu() const {}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_cpu(
    ::metrics::SystemProfileProto_Hardware_CPU* cpu) {}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::release_cpu() {}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::unsafe_arena_release_cpu() {}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::_internal_mutable_cpu() {}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::mutable_cpu() {}
inline void SystemProfileProto_Hardware::set_allocated_cpu(::metrics::SystemProfileProto_Hardware_CPU* cpu) {}

// optional .metrics.SystemProfileProto.Hardware.Motherboard motherboard = 25;
inline bool SystemProfileProto_Hardware::_internal_has_motherboard() const {}
inline bool SystemProfileProto_Hardware::has_motherboard() const {}
inline void SystemProfileProto_Hardware::clear_motherboard() {}
inline const ::metrics::SystemProfileProto_Hardware_Motherboard& SystemProfileProto_Hardware::_internal_motherboard() const {}
inline const ::metrics::SystemProfileProto_Hardware_Motherboard& SystemProfileProto_Hardware::motherboard() const {}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_motherboard(
    ::metrics::SystemProfileProto_Hardware_Motherboard* motherboard) {}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::release_motherboard() {}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::unsafe_arena_release_motherboard() {}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::_internal_mutable_motherboard() {}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::mutable_motherboard() {}
inline void SystemProfileProto_Hardware::set_allocated_motherboard(::metrics::SystemProfileProto_Hardware_Motherboard* motherboard) {}

// optional .metrics.SystemProfileProto.Hardware.Graphics gpu = 8;
inline bool SystemProfileProto_Hardware::_internal_has_gpu() const {}
inline bool SystemProfileProto_Hardware::has_gpu() const {}
inline void SystemProfileProto_Hardware::clear_gpu() {}
inline const ::metrics::SystemProfileProto_Hardware_Graphics& SystemProfileProto_Hardware::_internal_gpu() const {}
inline const ::metrics::SystemProfileProto_Hardware_Graphics& SystemProfileProto_Hardware::gpu() const {}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_gpu(
    ::metrics::SystemProfileProto_Hardware_Graphics* gpu) {}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::release_gpu() {}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::unsafe_arena_release_gpu() {}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::_internal_mutable_gpu() {}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::mutable_gpu() {}
inline void SystemProfileProto_Hardware::set_allocated_gpu(::metrics::SystemProfileProto_Hardware_Graphics* gpu) {}

// optional bool internal_display_supports_touch = 14;
inline bool SystemProfileProto_Hardware::_internal_has_internal_display_supports_touch() const {}
inline bool SystemProfileProto_Hardware::has_internal_display_supports_touch() const {}
inline void SystemProfileProto_Hardware::clear_internal_display_supports_touch() {}
inline bool SystemProfileProto_Hardware::_internal_internal_display_supports_touch() const {}
inline bool SystemProfileProto_Hardware::internal_display_supports_touch() const {}
inline void SystemProfileProto_Hardware::_internal_set_internal_display_supports_touch(bool value) {}
inline void SystemProfileProto_Hardware::set_internal_display_supports_touch(bool value) {}

// repeated .metrics.SystemProfileProto.Hardware.InternalStorageDevice internal_storage_devices = 20;
inline int SystemProfileProto_Hardware::_internal_internal_storage_devices_size() const {}
inline int SystemProfileProto_Hardware::internal_storage_devices_size() const {}
inline void SystemProfileProto_Hardware::clear_internal_storage_devices() {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* SystemProfileProto_Hardware::mutable_internal_storage_devices(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice >*
SystemProfileProto_Hardware::mutable_internal_storage_devices() {}
inline const ::metrics::SystemProfileProto_Hardware_InternalStorageDevice& SystemProfileProto_Hardware::_internal_internal_storage_devices(int index) const {}
inline const ::metrics::SystemProfileProto_Hardware_InternalStorageDevice& SystemProfileProto_Hardware::internal_storage_devices(int index) const {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* SystemProfileProto_Hardware::_internal_add_internal_storage_devices() {}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* SystemProfileProto_Hardware::add_internal_storage_devices() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice >&
SystemProfileProto_Hardware::internal_storage_devices() const {}

// optional .metrics.SystemProfileProto.Hardware.Drive app_drive = 16;
inline bool SystemProfileProto_Hardware::_internal_has_app_drive() const {}
inline bool SystemProfileProto_Hardware::has_app_drive() const {}
inline void SystemProfileProto_Hardware::clear_app_drive() {}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::_internal_app_drive() const {}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::app_drive() const {}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_app_drive(
    ::metrics::SystemProfileProto_Hardware_Drive* app_drive) {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::release_app_drive() {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::unsafe_arena_release_app_drive() {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::_internal_mutable_app_drive() {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::mutable_app_drive() {}
inline void SystemProfileProto_Hardware::set_allocated_app_drive(::metrics::SystemProfileProto_Hardware_Drive* app_drive) {}

// optional .metrics.SystemProfileProto.Hardware.Drive user_data_drive = 17;
inline bool SystemProfileProto_Hardware::_internal_has_user_data_drive() const {}
inline bool SystemProfileProto_Hardware::has_user_data_drive() const {}
inline void SystemProfileProto_Hardware::clear_user_data_drive() {}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::_internal_user_data_drive() const {}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::user_data_drive() const {}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_user_data_drive(
    ::metrics::SystemProfileProto_Hardware_Drive* user_data_drive) {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::release_user_data_drive() {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::unsafe_arena_release_user_data_drive() {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::_internal_mutable_user_data_drive() {}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::mutable_user_data_drive() {}
inline void SystemProfileProto_Hardware::set_allocated_user_data_drive(::metrics::SystemProfileProto_Hardware_Drive* user_data_drive) {}

// optional .metrics.SystemProfileProto.Hardware.TpmType tpm_type = 23;
inline bool SystemProfileProto_Hardware::_internal_has_tpm_type() const {}
inline bool SystemProfileProto_Hardware::has_tpm_type() const {}
inline void SystemProfileProto_Hardware::clear_tpm_type() {}
inline ::metrics::SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware::_internal_tpm_type() const {}
inline ::metrics::SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware::tpm_type() const {}
inline void SystemProfileProto_Hardware::_internal_set_tpm_type(::metrics::SystemProfileProto_Hardware_TpmType value) {}
inline void SystemProfileProto_Hardware::set_tpm_type(::metrics::SystemProfileProto_Hardware_TpmType value) {}

// optional uint64 tpm_firmware_version = 26;
inline bool SystemProfileProto_Hardware::_internal_has_tpm_firmware_version() const {}
inline bool SystemProfileProto_Hardware::has_tpm_firmware_version() const {}
inline void SystemProfileProto_Hardware::clear_tpm_firmware_version() {}
inline uint64_t SystemProfileProto_Hardware::_internal_tpm_firmware_version() const {}
inline uint64_t SystemProfileProto_Hardware::tpm_firmware_version() const {}
inline void SystemProfileProto_Hardware::_internal_set_tpm_firmware_version(uint64_t value) {}
inline void SystemProfileProto_Hardware::set_tpm_firmware_version(uint64_t value) {}

// optional string tpm_rw_firmware_version = 27;
inline bool SystemProfileProto_Hardware::_internal_has_tpm_rw_firmware_version() const {}
inline bool SystemProfileProto_Hardware::has_tpm_rw_firmware_version() const {}
inline void SystemProfileProto_Hardware::clear_tpm_rw_firmware_version() {}
inline const std::string& SystemProfileProto_Hardware::tpm_rw_firmware_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_tpm_rw_firmware_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_Hardware::mutable_tpm_rw_firmware_version() {}
inline const std::string& SystemProfileProto_Hardware::_internal_tpm_rw_firmware_version() const {}
inline void SystemProfileProto_Hardware::_internal_set_tpm_rw_firmware_version(const std::string& value) {}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_tpm_rw_firmware_version() {}
inline std::string* SystemProfileProto_Hardware::release_tpm_rw_firmware_version() {}
inline void SystemProfileProto_Hardware::set_allocated_tpm_rw_firmware_version(std::string* tpm_rw_firmware_version) {}

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

// SystemProfileProto_Network

// optional bool connection_type_is_ambiguous = 1;
inline bool SystemProfileProto_Network::_internal_has_connection_type_is_ambiguous() const {}
inline bool SystemProfileProto_Network::has_connection_type_is_ambiguous() const {}
inline void SystemProfileProto_Network::clear_connection_type_is_ambiguous() {}
inline bool SystemProfileProto_Network::_internal_connection_type_is_ambiguous() const {}
inline bool SystemProfileProto_Network::connection_type_is_ambiguous() const {}
inline void SystemProfileProto_Network::_internal_set_connection_type_is_ambiguous(bool value) {}
inline void SystemProfileProto_Network::set_connection_type_is_ambiguous(bool value) {}

// optional .metrics.SystemProfileProto.Network.ConnectionType connection_type = 2;
inline bool SystemProfileProto_Network::_internal_has_connection_type() const {}
inline bool SystemProfileProto_Network::has_connection_type() const {}
inline void SystemProfileProto_Network::clear_connection_type() {}
inline ::metrics::SystemProfileProto_Network_ConnectionType SystemProfileProto_Network::_internal_connection_type() const {}
inline ::metrics::SystemProfileProto_Network_ConnectionType SystemProfileProto_Network::connection_type() const {}
inline void SystemProfileProto_Network::_internal_set_connection_type(::metrics::SystemProfileProto_Network_ConnectionType value) {}
inline void SystemProfileProto_Network::set_connection_type(::metrics::SystemProfileProto_Network_ConnectionType value) {}

// optional .metrics.SystemProfileProto.Network.EffectiveConnectionType min_effective_connection_type = 7;
inline bool SystemProfileProto_Network::_internal_has_min_effective_connection_type() const {}
inline bool SystemProfileProto_Network::has_min_effective_connection_type() const {}
inline void SystemProfileProto_Network::clear_min_effective_connection_type() {}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::_internal_min_effective_connection_type() const {}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::min_effective_connection_type() const {}
inline void SystemProfileProto_Network::_internal_set_min_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {}
inline void SystemProfileProto_Network::set_min_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {}

// optional .metrics.SystemProfileProto.Network.EffectiveConnectionType max_effective_connection_type = 8;
inline bool SystemProfileProto_Network::_internal_has_max_effective_connection_type() const {}
inline bool SystemProfileProto_Network::has_max_effective_connection_type() const {}
inline void SystemProfileProto_Network::clear_max_effective_connection_type() {}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::_internal_max_effective_connection_type() const {}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::max_effective_connection_type() const {}
inline void SystemProfileProto_Network::_internal_set_max_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {}
inline void SystemProfileProto_Network::set_max_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {}

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

// SystemProfileProto_GoogleUpdate_ProductInfo

// optional string version = 1;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_version() const {}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_version() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_version() {}
inline const std::string& SystemProfileProto_GoogleUpdate_ProductInfo::version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_GoogleUpdate_ProductInfo::set_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_GoogleUpdate_ProductInfo::mutable_version() {}
inline const std::string& SystemProfileProto_GoogleUpdate_ProductInfo::_internal_version() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_version(const std::string& value) {}
inline std::string* SystemProfileProto_GoogleUpdate_ProductInfo::_internal_mutable_version() {}
inline std::string* SystemProfileProto_GoogleUpdate_ProductInfo::release_version() {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_allocated_version(std::string* version) {}

// optional int64 last_update_success_timestamp = 2;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_update_success_timestamp() const {}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_update_success_timestamp() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_update_success_timestamp() {}
inline int64_t SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_update_success_timestamp() const {}
inline int64_t SystemProfileProto_GoogleUpdate_ProductInfo::last_update_success_timestamp() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_update_success_timestamp(int64_t value) {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_update_success_timestamp(int64_t value) {}

// optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo.InstallResult last_result = 3;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_result() const {}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_result() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_result() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_result() const {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo::last_result() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_result(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value) {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_result(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value) {}

// optional int32 last_error = 4;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_error() const {}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_error() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_error() {}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_error() const {}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::last_error() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_error(int32_t value) {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_error(int32_t value) {}

// optional int32 last_extra_error = 5;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_extra_error() const {}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_extra_error() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_extra_error() {}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_extra_error() const {}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::last_extra_error() const {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_extra_error(int32_t value) {}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_extra_error(int32_t value) {}

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

// SystemProfileProto_GoogleUpdate

// optional bool is_system_install = 1;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_is_system_install() const {}
inline bool SystemProfileProto_GoogleUpdate::has_is_system_install() const {}
inline void SystemProfileProto_GoogleUpdate::clear_is_system_install() {}
inline bool SystemProfileProto_GoogleUpdate::_internal_is_system_install() const {}
inline bool SystemProfileProto_GoogleUpdate::is_system_install() const {}
inline void SystemProfileProto_GoogleUpdate::_internal_set_is_system_install(bool value) {}
inline void SystemProfileProto_GoogleUpdate::set_is_system_install(bool value) {}

// optional int64 last_automatic_start_timestamp = 2;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_last_automatic_start_timestamp() const {}
inline bool SystemProfileProto_GoogleUpdate::has_last_automatic_start_timestamp() const {}
inline void SystemProfileProto_GoogleUpdate::clear_last_automatic_start_timestamp() {}
inline int64_t SystemProfileProto_GoogleUpdate::_internal_last_automatic_start_timestamp() const {}
inline int64_t SystemProfileProto_GoogleUpdate::last_automatic_start_timestamp() const {}
inline void SystemProfileProto_GoogleUpdate::_internal_set_last_automatic_start_timestamp(int64_t value) {}
inline void SystemProfileProto_GoogleUpdate::set_last_automatic_start_timestamp(int64_t value) {}

// optional int64 last_update_check_timestamp = 3;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_last_update_check_timestamp() const {}
inline bool SystemProfileProto_GoogleUpdate::has_last_update_check_timestamp() const {}
inline void SystemProfileProto_GoogleUpdate::clear_last_update_check_timestamp() {}
inline int64_t SystemProfileProto_GoogleUpdate::_internal_last_update_check_timestamp() const {}
inline int64_t SystemProfileProto_GoogleUpdate::last_update_check_timestamp() const {}
inline void SystemProfileProto_GoogleUpdate::_internal_set_last_update_check_timestamp(int64_t value) {}
inline void SystemProfileProto_GoogleUpdate::set_last_update_check_timestamp(int64_t value) {}

// optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo google_update_status = 4;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_google_update_status() const {}
inline bool SystemProfileProto_GoogleUpdate::has_google_update_status() const {}
inline void SystemProfileProto_GoogleUpdate::clear_google_update_status() {}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::_internal_google_update_status() const {}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::google_update_status() const {}
inline void SystemProfileProto_GoogleUpdate::unsafe_arena_set_allocated_google_update_status(
    ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status) {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::release_google_update_status() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::unsafe_arena_release_google_update_status() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::_internal_mutable_google_update_status() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::mutable_google_update_status() {}
inline void SystemProfileProto_GoogleUpdate::set_allocated_google_update_status(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status) {}

// optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo client_status = 5;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_client_status() const {}
inline bool SystemProfileProto_GoogleUpdate::has_client_status() const {}
inline void SystemProfileProto_GoogleUpdate::clear_client_status() {}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::_internal_client_status() const {}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::client_status() const {}
inline void SystemProfileProto_GoogleUpdate::unsafe_arena_set_allocated_client_status(
    ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status) {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::release_client_status() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::unsafe_arena_release_client_status() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::_internal_mutable_client_status() {}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::mutable_client_status() {}
inline void SystemProfileProto_GoogleUpdate::set_allocated_client_status(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status) {}

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

// SystemProfileProto_Stability

// optional int64 incremental_uptime_sec = 1;
inline bool SystemProfileProto_Stability::_internal_has_incremental_uptime_sec() const {}
inline bool SystemProfileProto_Stability::has_incremental_uptime_sec() const {}
inline void SystemProfileProto_Stability::clear_incremental_uptime_sec() {}
inline int64_t SystemProfileProto_Stability::_internal_incremental_uptime_sec() const {}
inline int64_t SystemProfileProto_Stability::incremental_uptime_sec() const {}
inline void SystemProfileProto_Stability::_internal_set_incremental_uptime_sec(int64_t value) {}
inline void SystemProfileProto_Stability::set_incremental_uptime_sec(int64_t value) {}

// optional int64 uptime_sec = 23;
inline bool SystemProfileProto_Stability::_internal_has_uptime_sec() const {}
inline bool SystemProfileProto_Stability::has_uptime_sec() const {}
inline void SystemProfileProto_Stability::clear_uptime_sec() {}
inline int64_t SystemProfileProto_Stability::_internal_uptime_sec() const {}
inline int64_t SystemProfileProto_Stability::uptime_sec() const {}
inline void SystemProfileProto_Stability::_internal_set_uptime_sec(int64_t value) {}
inline void SystemProfileProto_Stability::set_uptime_sec(int64_t value) {}

// optional int32 page_load_count = 2;
inline bool SystemProfileProto_Stability::_internal_has_page_load_count() const {}
inline bool SystemProfileProto_Stability::has_page_load_count() const {}
inline void SystemProfileProto_Stability::clear_page_load_count() {}
inline int32_t SystemProfileProto_Stability::_internal_page_load_count() const {}
inline int32_t SystemProfileProto_Stability::page_load_count() const {}
inline void SystemProfileProto_Stability::_internal_set_page_load_count(int32_t value) {}
inline void SystemProfileProto_Stability::set_page_load_count(int32_t value) {}

// optional int32 renderer_launch_count = 26;
inline bool SystemProfileProto_Stability::_internal_has_renderer_launch_count() const {}
inline bool SystemProfileProto_Stability::has_renderer_launch_count() const {}
inline void SystemProfileProto_Stability::clear_renderer_launch_count() {}
inline int32_t SystemProfileProto_Stability::_internal_renderer_launch_count() const {}
inline int32_t SystemProfileProto_Stability::renderer_launch_count() const {}
inline void SystemProfileProto_Stability::_internal_set_renderer_launch_count(int32_t value) {}
inline void SystemProfileProto_Stability::set_renderer_launch_count(int32_t value) {}

// optional int32 other_user_crash_count = 7;
inline bool SystemProfileProto_Stability::_internal_has_other_user_crash_count() const {}
inline bool SystemProfileProto_Stability::has_other_user_crash_count() const {}
inline void SystemProfileProto_Stability::clear_other_user_crash_count() {}
inline int32_t SystemProfileProto_Stability::_internal_other_user_crash_count() const {}
inline int32_t SystemProfileProto_Stability::other_user_crash_count() const {}
inline void SystemProfileProto_Stability::_internal_set_other_user_crash_count(int32_t value) {}
inline void SystemProfileProto_Stability::set_other_user_crash_count(int32_t value) {}

// optional int32 kernel_crash_count = 8;
inline bool SystemProfileProto_Stability::_internal_has_kernel_crash_count() const {}
inline bool SystemProfileProto_Stability::has_kernel_crash_count() const {}
inline void SystemProfileProto_Stability::clear_kernel_crash_count() {}
inline int32_t SystemProfileProto_Stability::_internal_kernel_crash_count() const {}
inline int32_t SystemProfileProto_Stability::kernel_crash_count() const {}
inline void SystemProfileProto_Stability::_internal_set_kernel_crash_count(int32_t value) {}
inline void SystemProfileProto_Stability::set_kernel_crash_count(int32_t value) {}

// optional int32 unclean_system_shutdown_count = 9;
inline bool SystemProfileProto_Stability::_internal_has_unclean_system_shutdown_count() const {}
inline bool SystemProfileProto_Stability::has_unclean_system_shutdown_count() const {}
inline void SystemProfileProto_Stability::clear_unclean_system_shutdown_count() {}
inline int32_t SystemProfileProto_Stability::_internal_unclean_system_shutdown_count() const {}
inline int32_t SystemProfileProto_Stability::unclean_system_shutdown_count() const {}
inline void SystemProfileProto_Stability::_internal_set_unclean_system_shutdown_count(int32_t value) {}
inline void SystemProfileProto_Stability::set_unclean_system_shutdown_count(int32_t value) {}

// optional int32 launch_count = 15;
inline bool SystemProfileProto_Stability::_internal_has_launch_count() const {}
inline bool SystemProfileProto_Stability::has_launch_count() const {}
inline void SystemProfileProto_Stability::clear_launch_count() {}
inline int32_t SystemProfileProto_Stability::_internal_launch_count() const {}
inline int32_t SystemProfileProto_Stability::launch_count() const {}
inline void SystemProfileProto_Stability::_internal_set_launch_count(int32_t value) {}
inline void SystemProfileProto_Stability::set_launch_count(int32_t value) {}

// optional int32 crash_count_due_to_gms_core_update = 30;
inline bool SystemProfileProto_Stability::_internal_has_crash_count_due_to_gms_core_update() const {}
inline bool SystemProfileProto_Stability::has_crash_count_due_to_gms_core_update() const {}
inline void SystemProfileProto_Stability::clear_crash_count_due_to_gms_core_update() {}
inline int32_t SystemProfileProto_Stability::_internal_crash_count_due_to_gms_core_update() const {}
inline int32_t SystemProfileProto_Stability::crash_count_due_to_gms_core_update() const {}
inline void SystemProfileProto_Stability::_internal_set_crash_count_due_to_gms_core_update(int32_t value) {}
inline void SystemProfileProto_Stability::set_crash_count_due_to_gms_core_update(int32_t value) {}

// optional bool from_previous_run = 29;
inline bool SystemProfileProto_Stability::_internal_has_from_previous_run() const {}
inline bool SystemProfileProto_Stability::has_from_previous_run() const {}
inline void SystemProfileProto_Stability::clear_from_previous_run() {}
inline bool SystemProfileProto_Stability::_internal_from_previous_run() const {}
inline bool SystemProfileProto_Stability::from_previous_run() const {}
inline void SystemProfileProto_Stability::_internal_set_from_previous_run(bool value) {}
inline void SystemProfileProto_Stability::set_from_previous_run(bool value) {}

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

// SystemProfileProto_FieldTrial

// optional fixed32 name_id = 1;
inline bool SystemProfileProto_FieldTrial::_internal_has_name_id() const {}
inline bool SystemProfileProto_FieldTrial::has_name_id() const {}
inline void SystemProfileProto_FieldTrial::clear_name_id() {}
inline uint32_t SystemProfileProto_FieldTrial::_internal_name_id() const {}
inline uint32_t SystemProfileProto_FieldTrial::name_id() const {}
inline void SystemProfileProto_FieldTrial::_internal_set_name_id(uint32_t value) {}
inline void SystemProfileProto_FieldTrial::set_name_id(uint32_t value) {}

// optional fixed32 group_id = 2;
inline bool SystemProfileProto_FieldTrial::_internal_has_group_id() const {}
inline bool SystemProfileProto_FieldTrial::has_group_id() const {}
inline void SystemProfileProto_FieldTrial::clear_group_id() {}
inline uint32_t SystemProfileProto_FieldTrial::_internal_group_id() const {}
inline uint32_t SystemProfileProto_FieldTrial::group_id() const {}
inline void SystemProfileProto_FieldTrial::_internal_set_group_id(uint32_t value) {}
inline void SystemProfileProto_FieldTrial::set_group_id(uint32_t value) {}

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

// SystemProfileProto_ExternalAudioVideoDevice_AudioDescription

// optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.AudioFormat audio_format = 1;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_audio_format() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_audio_format() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_audio_format() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_audio_format() const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::audio_format() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_audio_format(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_audio_format(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value) {}

// optional int32 num_channels = 2;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_num_channels() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_num_channels() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_num_channels() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_num_channels() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::num_channels() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_num_channels(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_num_channels(int32_t value) {}

// repeated int32 sample_frequency_hz = 3;
inline int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_sample_frequency_hz_size() const {}
inline int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::sample_frequency_hz_size() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_sample_frequency_hz() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_sample_frequency_hz(int index) const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::sample_frequency_hz(int index) const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_sample_frequency_hz(int index, int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_add_sample_frequency_hz(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::add_sample_frequency_hz(int32_t value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_sample_frequency_hz() const {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::sample_frequency_hz() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_mutable_sample_frequency_hz() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::mutable_sample_frequency_hz() {}

// optional int32 max_bit_rate_per_second = 4;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_max_bit_rate_per_second() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_max_bit_rate_per_second() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_max_bit_rate_per_second() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_max_bit_rate_per_second() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::max_bit_rate_per_second() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_max_bit_rate_per_second(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_max_bit_rate_per_second(int32_t value) {}

// optional int32 bit_depth = 5;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_bit_depth() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_bit_depth() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_bit_depth() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_bit_depth() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::bit_depth() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_bit_depth(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_bit_depth(int32_t value) {}

// optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.OutputMode output_mode = 6;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_output_mode() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_output_mode() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_output_mode() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_output_mode() const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::output_mode() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_output_mode(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_output_mode(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value) {}

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

// SystemProfileProto_ExternalAudioVideoDevice_CECCommand

// optional int32 opcode = 1;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_opcode() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_opcode() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_opcode() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_opcode() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::opcode() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_opcode(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_opcode(int32_t value) {}

// optional int32 num_received_direct = 2;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_received_direct() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_received_direct() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_received_direct() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_received_direct() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_received_direct() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_received_direct(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_received_direct(int32_t value) {}

// optional int32 num_received_broadcast = 3;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_received_broadcast() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_received_broadcast() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_received_broadcast() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_received_broadcast() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_received_broadcast() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_received_broadcast(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_received_broadcast(int32_t value) {}

// optional int32 num_sent_direct = 4;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_sent_direct() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_sent_direct() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_sent_direct() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_sent_direct() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_sent_direct() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_sent_direct(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_sent_direct(int32_t value) {}

// optional int32 num_sent_broadcast = 5;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_sent_broadcast() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_sent_broadcast() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_sent_broadcast() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_sent_broadcast() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_sent_broadcast() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_sent_broadcast(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_sent_broadcast(int32_t value) {}

// optional int32 num_aborted_unknown_reason = 6;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_aborted_unknown_reason() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_aborted_unknown_reason() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_aborted_unknown_reason() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_aborted_unknown_reason() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_aborted_unknown_reason() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_aborted_unknown_reason(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_aborted_unknown_reason(int32_t value) {}

// optional int32 num_aborted_unrecognized = 7;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_aborted_unrecognized() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_aborted_unrecognized() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_aborted_unrecognized() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_aborted_unrecognized() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_aborted_unrecognized() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_aborted_unrecognized(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_aborted_unrecognized(int32_t value) {}

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

// SystemProfileProto_ExternalAudioVideoDevice

// optional string manufacturer_name = 1;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_manufacturer_name() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_manufacturer_name() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_manufacturer_name() {}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::manufacturer_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAudioVideoDevice::set_manufacturer_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::mutable_manufacturer_name() {}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::_internal_manufacturer_name() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_manufacturer_name(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_manufacturer_name() {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::release_manufacturer_name() {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_allocated_manufacturer_name(std::string* manufacturer_name) {}

// optional string model_name = 2;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_model_name() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_model_name() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_model_name() {}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::model_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAudioVideoDevice::set_model_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::mutable_model_name() {}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::_internal_model_name() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_model_name(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_model_name() {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::release_model_name() {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_allocated_model_name(std::string* model_name) {}

// optional string product_code = 3;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_product_code() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_product_code() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_product_code() {}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::product_code() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAudioVideoDevice::set_product_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::mutable_product_code() {}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::_internal_product_code() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_product_code(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_product_code() {}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::release_product_code() {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_allocated_product_code(std::string* product_code) {}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.AVDeviceType av_device_type = 4;
inline int SystemProfileProto_ExternalAudioVideoDevice::_internal_av_device_type_size() const {}
inline int SystemProfileProto_ExternalAudioVideoDevice::av_device_type_size() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_av_device_type() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice::_internal_av_device_type(int index) const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice::av_device_type(int index) const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_av_device_type(int index, ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_add_av_device_type(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::add_av_device_type(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SystemProfileProto_ExternalAudioVideoDevice::av_device_type() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_av_device_type() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_ExternalAudioVideoDevice::mutable_av_device_type() {}

// optional int32 manufacture_year = 5;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_manufacture_year() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_manufacture_year() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_manufacture_year() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_manufacture_year() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::manufacture_year() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_manufacture_year(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_manufacture_year(int32_t value) {}

// optional int32 manufacture_week = 6;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_manufacture_week() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_manufacture_week() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_manufacture_week() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_manufacture_week() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::manufacture_week() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_manufacture_week(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_manufacture_week(int32_t value) {}

// optional int32 horizontal_resolution = 7;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_horizontal_resolution() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_horizontal_resolution() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_horizontal_resolution() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_horizontal_resolution() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::horizontal_resolution() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_horizontal_resolution(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_horizontal_resolution(int32_t value) {}

// optional int32 vertical_resolution = 8;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_vertical_resolution() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_vertical_resolution() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_vertical_resolution() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_vertical_resolution() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::vertical_resolution() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_vertical_resolution(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_vertical_resolution(int32_t value) {}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription audio_description = 9;
inline int SystemProfileProto_ExternalAudioVideoDevice::_internal_audio_description_size() const {}
inline int SystemProfileProto_ExternalAudioVideoDevice::audio_description_size() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_audio_description() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* SystemProfileProto_ExternalAudioVideoDevice::mutable_audio_description(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription >*
SystemProfileProto_ExternalAudioVideoDevice::mutable_audio_description() {}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& SystemProfileProto_ExternalAudioVideoDevice::_internal_audio_description(int index) const {}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& SystemProfileProto_ExternalAudioVideoDevice::audio_description(int index) const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* SystemProfileProto_ExternalAudioVideoDevice::_internal_add_audio_description() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* SystemProfileProto_ExternalAudioVideoDevice::add_audio_description() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription >&
SystemProfileProto_ExternalAudioVideoDevice::audio_description() const {}

// optional int32 position_in_setup = 10;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_position_in_setup() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_position_in_setup() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_position_in_setup() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_position_in_setup() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::position_in_setup() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_position_in_setup(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_position_in_setup(int32_t value) {}

// optional bool is_in_path_to_tv = 11;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_is_in_path_to_tv() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_is_in_path_to_tv() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_is_in_path_to_tv() {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_is_in_path_to_tv() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::is_in_path_to_tv() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_is_in_path_to_tv(bool value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_is_in_path_to_tv(bool value) {}

// optional int32 cec_version = 12;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_cec_version() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_cec_version() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_cec_version() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_cec_version() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::cec_version() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_cec_version(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_cec_version(int32_t value) {}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand cec_command = 13;
inline int SystemProfileProto_ExternalAudioVideoDevice::_internal_cec_command_size() const {}
inline int SystemProfileProto_ExternalAudioVideoDevice::cec_command_size() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_cec_command() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* SystemProfileProto_ExternalAudioVideoDevice::mutable_cec_command(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand >*
SystemProfileProto_ExternalAudioVideoDevice::mutable_cec_command() {}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand& SystemProfileProto_ExternalAudioVideoDevice::_internal_cec_command(int index) const {}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand& SystemProfileProto_ExternalAudioVideoDevice::cec_command(int index) const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* SystemProfileProto_ExternalAudioVideoDevice::_internal_add_cec_command() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* SystemProfileProto_ExternalAudioVideoDevice::add_cec_command() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand >&
SystemProfileProto_ExternalAudioVideoDevice::cec_command() const {}

// optional int32 frame_rate = 14;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_frame_rate() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_frame_rate() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_frame_rate() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_frame_rate() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::frame_rate() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_frame_rate(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_frame_rate(int32_t value) {}

// optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.ColorEncoding color_encoding = 15;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_color_encoding() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_color_encoding() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_color_encoding() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice::_internal_color_encoding() const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice::color_encoding() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_color_encoding(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_color_encoding(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value) {}

// optional int32 bit_depth = 16;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_bit_depth() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_bit_depth() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_bit_depth() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_bit_depth() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::bit_depth() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_bit_depth(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_bit_depth(int32_t value) {}

// optional int32 tmds = 17;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_tmds() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_tmds() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_tmds() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_tmds() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::tmds() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_tmds(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_tmds(int32_t value) {}

// optional bool hdr10_support = 18;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_hdr10_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_hdr10_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_hdr10_support() {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_hdr10_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::hdr10_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_hdr10_support(bool value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_hdr10_support(bool value) {}

// optional bool dolby_vision_support = 19;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_dolby_vision_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_dolby_vision_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_dolby_vision_support() {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_dolby_vision_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::dolby_vision_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_dolby_vision_support(bool value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_dolby_vision_support(bool value) {}

// optional int32 eotf_support = 20;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_eotf_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_eotf_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_eotf_support() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_eotf_support() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::eotf_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_eotf_support(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_eotf_support(int32_t value) {}

// optional bool yuv_support = 21;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_yuv_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_yuv_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_yuv_support() {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_yuv_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::yuv_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_yuv_support(bool value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_yuv_support(bool value) {}

// optional bool yuv_420_support = 22;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_yuv_420_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_yuv_420_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_yuv_420_support() {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_yuv_420_support() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::yuv_420_support() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_yuv_420_support(bool value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_yuv_420_support(bool value) {}

// optional int32 maximum_supported_hdcp_version = 23;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_maximum_supported_hdcp_version() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_maximum_supported_hdcp_version() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_maximum_supported_hdcp_version() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_maximum_supported_hdcp_version() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::maximum_supported_hdcp_version() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_maximum_supported_hdcp_version(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_maximum_supported_hdcp_version(int32_t value) {}

// optional int32 current_hdcp_version = 24;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_current_hdcp_version() const {}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_current_hdcp_version() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_current_hdcp_version() {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_current_hdcp_version() const {}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::current_hdcp_version() const {}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_current_hdcp_version(int32_t value) {}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_current_hdcp_version(int32_t value) {}

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

// SystemProfileProto_ExternalAccessPoint

// optional string manufacturer = 1;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_manufacturer() const {}
inline bool SystemProfileProto_ExternalAccessPoint::has_manufacturer() const {}
inline void SystemProfileProto_ExternalAccessPoint::clear_manufacturer() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::manufacturer() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_manufacturer(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_manufacturer() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_manufacturer() const {}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_manufacturer(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_manufacturer() {}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_manufacturer() {}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_manufacturer(std::string* manufacturer) {}

// optional string model_name = 2;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_model_name() const {}
inline bool SystemProfileProto_ExternalAccessPoint::has_model_name() const {}
inline void SystemProfileProto_ExternalAccessPoint::clear_model_name() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::model_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_model_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_model_name() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_model_name() const {}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_model_name(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_model_name() {}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_model_name() {}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_model_name(std::string* model_name) {}

// optional string model_number = 3;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_model_number() const {}
inline bool SystemProfileProto_ExternalAccessPoint::has_model_number() const {}
inline void SystemProfileProto_ExternalAccessPoint::clear_model_number() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::model_number() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_model_number(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_model_number() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_model_number() const {}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_model_number(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_model_number() {}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_model_number() {}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_model_number(std::string* model_number) {}

// optional string device_name = 4;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_device_name() const {}
inline bool SystemProfileProto_ExternalAccessPoint::has_device_name() const {}
inline void SystemProfileProto_ExternalAccessPoint::clear_device_name() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::device_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_device_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_device_name() {}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_device_name() const {}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_device_name(const std::string& value) {}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_device_name() {}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_device_name() {}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_device_name(std::string* device_name) {}

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

// SystemProfileProto_AntiVirusProduct

// optional string product_name = 1;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_name() const {}
inline bool SystemProfileProto_AntiVirusProduct::has_product_name() const {}
inline void SystemProfileProto_AntiVirusProduct::clear_product_name() {}
inline const std::string& SystemProfileProto_AntiVirusProduct::product_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_AntiVirusProduct::set_product_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_AntiVirusProduct::mutable_product_name() {}
inline const std::string& SystemProfileProto_AntiVirusProduct::_internal_product_name() const {}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_name(const std::string& value) {}
inline std::string* SystemProfileProto_AntiVirusProduct::_internal_mutable_product_name() {}
inline std::string* SystemProfileProto_AntiVirusProduct::release_product_name() {}
inline void SystemProfileProto_AntiVirusProduct::set_allocated_product_name(std::string* product_name) {}

// optional fixed32 product_name_hash = 2;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_name_hash() const {}
inline bool SystemProfileProto_AntiVirusProduct::has_product_name_hash() const {}
inline void SystemProfileProto_AntiVirusProduct::clear_product_name_hash() {}
inline uint32_t SystemProfileProto_AntiVirusProduct::_internal_product_name_hash() const {}
inline uint32_t SystemProfileProto_AntiVirusProduct::product_name_hash() const {}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_name_hash(uint32_t value) {}
inline void SystemProfileProto_AntiVirusProduct::set_product_name_hash(uint32_t value) {}

// optional string product_version = 3;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_version() const {}
inline bool SystemProfileProto_AntiVirusProduct::has_product_version() const {}
inline void SystemProfileProto_AntiVirusProduct::clear_product_version() {}
inline const std::string& SystemProfileProto_AntiVirusProduct::product_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_AntiVirusProduct::set_product_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_AntiVirusProduct::mutable_product_version() {}
inline const std::string& SystemProfileProto_AntiVirusProduct::_internal_product_version() const {}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_version(const std::string& value) {}
inline std::string* SystemProfileProto_AntiVirusProduct::_internal_mutable_product_version() {}
inline std::string* SystemProfileProto_AntiVirusProduct::release_product_version() {}
inline void SystemProfileProto_AntiVirusProduct::set_allocated_product_version(std::string* product_version) {}

// optional fixed32 product_version_hash = 4;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_version_hash() const {}
inline bool SystemProfileProto_AntiVirusProduct::has_product_version_hash() const {}
inline void SystemProfileProto_AntiVirusProduct::clear_product_version_hash() {}
inline uint32_t SystemProfileProto_AntiVirusProduct::_internal_product_version_hash() const {}
inline uint32_t SystemProfileProto_AntiVirusProduct::product_version_hash() const {}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_version_hash(uint32_t value) {}
inline void SystemProfileProto_AntiVirusProduct::set_product_version_hash(uint32_t value) {}

// optional .metrics.SystemProfileProto.AntiVirusState product_state = 5;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_state() const {}
inline bool SystemProfileProto_AntiVirusProduct::has_product_state() const {}
inline void SystemProfileProto_AntiVirusProduct::clear_product_state() {}
inline ::metrics::SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusProduct::_internal_product_state() const {}
inline ::metrics::SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusProduct::product_state() const {}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_state(::metrics::SystemProfileProto_AntiVirusState value) {}
inline void SystemProfileProto_AntiVirusProduct::set_product_state(::metrics::SystemProfileProto_AntiVirusState value) {}

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

// SystemProfileProto_ChromeComponent

// optional .metrics.SystemProfileProto.ComponentId component_id = 1 [default = UNKNOWN];
inline bool SystemProfileProto_ChromeComponent::_internal_has_component_id() const {}
inline bool SystemProfileProto_ChromeComponent::has_component_id() const {}
inline void SystemProfileProto_ChromeComponent::clear_component_id() {}
inline ::metrics::SystemProfileProto_ComponentId SystemProfileProto_ChromeComponent::_internal_component_id() const {}
inline ::metrics::SystemProfileProto_ComponentId SystemProfileProto_ChromeComponent::component_id() const {}
inline void SystemProfileProto_ChromeComponent::_internal_set_component_id(::metrics::SystemProfileProto_ComponentId value) {}
inline void SystemProfileProto_ChromeComponent::set_component_id(::metrics::SystemProfileProto_ComponentId value) {}

// optional string version = 2;
inline bool SystemProfileProto_ChromeComponent::_internal_has_version() const {}
inline bool SystemProfileProto_ChromeComponent::has_version() const {}
inline void SystemProfileProto_ChromeComponent::clear_version() {}
inline const std::string& SystemProfileProto_ChromeComponent::version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ChromeComponent::set_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_ChromeComponent::mutable_version() {}
inline const std::string& SystemProfileProto_ChromeComponent::_internal_version() const {}
inline void SystemProfileProto_ChromeComponent::_internal_set_version(const std::string& value) {}
inline std::string* SystemProfileProto_ChromeComponent::_internal_mutable_version() {}
inline std::string* SystemProfileProto_ChromeComponent::release_version() {}
inline void SystemProfileProto_ChromeComponent::set_allocated_version(std::string* version) {}

// optional fixed32 omaha_fingerprint = 3;
inline bool SystemProfileProto_ChromeComponent::_internal_has_omaha_fingerprint() const {}
inline bool SystemProfileProto_ChromeComponent::has_omaha_fingerprint() const {}
inline void SystemProfileProto_ChromeComponent::clear_omaha_fingerprint() {}
inline uint32_t SystemProfileProto_ChromeComponent::_internal_omaha_fingerprint() const {}
inline uint32_t SystemProfileProto_ChromeComponent::omaha_fingerprint() const {}
inline void SystemProfileProto_ChromeComponent::_internal_set_omaha_fingerprint(uint32_t value) {}
inline void SystemProfileProto_ChromeComponent::set_omaha_fingerprint(uint32_t value) {}

// optional fixed32 cohort_hash = 4;
inline bool SystemProfileProto_ChromeComponent::_internal_has_cohort_hash() const {}
inline bool SystemProfileProto_ChromeComponent::has_cohort_hash() const {}
inline void SystemProfileProto_ChromeComponent::clear_cohort_hash() {}
inline uint32_t SystemProfileProto_ChromeComponent::_internal_cohort_hash() const {}
inline uint32_t SystemProfileProto_ChromeComponent::cohort_hash() const {}
inline void SystemProfileProto_ChromeComponent::_internal_set_cohort_hash(uint32_t value) {}
inline void SystemProfileProto_ChromeComponent::set_cohort_hash(uint32_t value) {}

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

// SystemProfileProto_LinkedAndroidPhoneData

// optional fixed32 phone_model_name_hash = 1;
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_phone_model_name_hash() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_phone_model_name_hash() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_phone_model_name_hash() {}
inline uint32_t SystemProfileProto_LinkedAndroidPhoneData::_internal_phone_model_name_hash() const {}
inline uint32_t SystemProfileProto_LinkedAndroidPhoneData::phone_model_name_hash() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_phone_model_name_hash(uint32_t value) {}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_phone_model_name_hash(uint32_t value) {}

// optional bool is_smartlock_enabled = 2;
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_is_smartlock_enabled() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_is_smartlock_enabled() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_is_smartlock_enabled() {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_is_smartlock_enabled() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::is_smartlock_enabled() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_is_smartlock_enabled(bool value) {}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_is_smartlock_enabled(bool value) {}

// optional bool is_instant_tethering_enabled = 3;
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_is_instant_tethering_enabled() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_is_instant_tethering_enabled() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_is_instant_tethering_enabled() {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_is_instant_tethering_enabled() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::is_instant_tethering_enabled() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_is_instant_tethering_enabled(bool value) {}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_is_instant_tethering_enabled(bool value) {}

// optional bool is_messages_enabled = 4 [deprecated = true];
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_is_messages_enabled() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_is_messages_enabled() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_is_messages_enabled() {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_is_messages_enabled() const {}
inline bool SystemProfileProto_LinkedAndroidPhoneData::is_messages_enabled() const {}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_is_messages_enabled(bool value) {}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_is_messages_enabled(bool value) {}

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

// SystemProfileProto_DemoModeDimensions_Retailer

// optional string retailer_id = 1;
inline bool SystemProfileProto_DemoModeDimensions_Retailer::_internal_has_retailer_id() const {}
inline bool SystemProfileProto_DemoModeDimensions_Retailer::has_retailer_id() const {}
inline void SystemProfileProto_DemoModeDimensions_Retailer::clear_retailer_id() {}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::retailer_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions_Retailer::set_retailer_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::mutable_retailer_id() {}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::_internal_retailer_id() const {}
inline void SystemProfileProto_DemoModeDimensions_Retailer::_internal_set_retailer_id(const std::string& value) {}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::_internal_mutable_retailer_id() {}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::release_retailer_id() {}
inline void SystemProfileProto_DemoModeDimensions_Retailer::set_allocated_retailer_id(std::string* retailer_id) {}

// optional string store_id = 2;
inline bool SystemProfileProto_DemoModeDimensions_Retailer::_internal_has_store_id() const {}
inline bool SystemProfileProto_DemoModeDimensions_Retailer::has_store_id() const {}
inline void SystemProfileProto_DemoModeDimensions_Retailer::clear_store_id() {}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::store_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions_Retailer::set_store_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::mutable_store_id() {}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::_internal_store_id() const {}
inline void SystemProfileProto_DemoModeDimensions_Retailer::_internal_set_store_id(const std::string& value) {}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::_internal_mutable_store_id() {}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::release_store_id() {}
inline void SystemProfileProto_DemoModeDimensions_Retailer::set_allocated_store_id(std::string* store_id) {}

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

// SystemProfileProto_DemoModeDimensions

// optional string country = 1;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_country() const {}
inline bool SystemProfileProto_DemoModeDimensions::has_country() const {}
inline void SystemProfileProto_DemoModeDimensions::clear_country() {}
inline const std::string& SystemProfileProto_DemoModeDimensions::country() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions::set_country(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_DemoModeDimensions::mutable_country() {}
inline const std::string& SystemProfileProto_DemoModeDimensions::_internal_country() const {}
inline void SystemProfileProto_DemoModeDimensions::_internal_set_country(const std::string& value) {}
inline std::string* SystemProfileProto_DemoModeDimensions::_internal_mutable_country() {}
inline std::string* SystemProfileProto_DemoModeDimensions::release_country() {}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_country(std::string* country) {}

// optional .metrics.SystemProfileProto.DemoModeDimensions.Retailer retailer = 2;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_retailer() const {}
inline bool SystemProfileProto_DemoModeDimensions::has_retailer() const {}
inline void SystemProfileProto_DemoModeDimensions::clear_retailer() {}
inline const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer& SystemProfileProto_DemoModeDimensions::_internal_retailer() const {}
inline const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer& SystemProfileProto_DemoModeDimensions::retailer() const {}
inline void SystemProfileProto_DemoModeDimensions::unsafe_arena_set_allocated_retailer(
    ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer) {}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::release_retailer() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::unsafe_arena_release_retailer() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::_internal_mutable_retailer() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::mutable_retailer() {}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_retailer(::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer) {}

// repeated .metrics.SystemProfileProto.DemoModeDimensions.CustomizationFacet customization_facet = 3 [packed = true];
inline int SystemProfileProto_DemoModeDimensions::_internal_customization_facet_size() const {}
inline int SystemProfileProto_DemoModeDimensions::customization_facet_size() const {}
inline void SystemProfileProto_DemoModeDimensions::clear_customization_facet() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions::_internal_customization_facet(int index) const {}
inline ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions::customization_facet(int index) const {}
inline void SystemProfileProto_DemoModeDimensions::set_customization_facet(int index, ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value) {}
inline void SystemProfileProto_DemoModeDimensions::_internal_add_customization_facet(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value) {}
inline void SystemProfileProto_DemoModeDimensions::add_customization_facet(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SystemProfileProto_DemoModeDimensions::customization_facet() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_DemoModeDimensions::_internal_mutable_customization_facet() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_DemoModeDimensions::mutable_customization_facet() {}

// optional string app_version = 4;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_app_version() const {}
inline bool SystemProfileProto_DemoModeDimensions::has_app_version() const {}
inline void SystemProfileProto_DemoModeDimensions::clear_app_version() {}
inline const std::string& SystemProfileProto_DemoModeDimensions::app_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions::set_app_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_DemoModeDimensions::mutable_app_version() {}
inline const std::string& SystemProfileProto_DemoModeDimensions::_internal_app_version() const {}
inline void SystemProfileProto_DemoModeDimensions::_internal_set_app_version(const std::string& value) {}
inline std::string* SystemProfileProto_DemoModeDimensions::_internal_mutable_app_version() {}
inline std::string* SystemProfileProto_DemoModeDimensions::release_app_version() {}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_app_version(std::string* app_version) {}

// optional string resources_version = 5;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_resources_version() const {}
inline bool SystemProfileProto_DemoModeDimensions::has_resources_version() const {}
inline void SystemProfileProto_DemoModeDimensions::clear_resources_version() {}
inline const std::string& SystemProfileProto_DemoModeDimensions::resources_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions::set_resources_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto_DemoModeDimensions::mutable_resources_version() {}
inline const std::string& SystemProfileProto_DemoModeDimensions::_internal_resources_version() const {}
inline void SystemProfileProto_DemoModeDimensions::_internal_set_resources_version(const std::string& value) {}
inline std::string* SystemProfileProto_DemoModeDimensions::_internal_mutable_resources_version() {}
inline std::string* SystemProfileProto_DemoModeDimensions::release_resources_version() {}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_resources_version(std::string* resources_version) {}

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

// SystemProfileProto

// optional int64 build_timestamp = 1;
inline bool SystemProfileProto::_internal_has_build_timestamp() const {}
inline bool SystemProfileProto::has_build_timestamp() const {}
inline void SystemProfileProto::clear_build_timestamp() {}
inline int64_t SystemProfileProto::_internal_build_timestamp() const {}
inline int64_t SystemProfileProto::build_timestamp() const {}
inline void SystemProfileProto::_internal_set_build_timestamp(int64_t value) {}
inline void SystemProfileProto::set_build_timestamp(int64_t value) {}

// optional string app_version = 2;
inline bool SystemProfileProto::_internal_has_app_version() const {}
inline bool SystemProfileProto::has_app_version() const {}
inline void SystemProfileProto::clear_app_version() {}
inline const std::string& SystemProfileProto::app_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_app_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_app_version() {}
inline const std::string& SystemProfileProto::_internal_app_version() const {}
inline void SystemProfileProto::_internal_set_app_version(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_app_version() {}
inline std::string* SystemProfileProto::release_app_version() {}
inline void SystemProfileProto::set_allocated_app_version(std::string* app_version) {}

// optional string log_written_by_app_version = 40;
inline bool SystemProfileProto::_internal_has_log_written_by_app_version() const {}
inline bool SystemProfileProto::has_log_written_by_app_version() const {}
inline void SystemProfileProto::clear_log_written_by_app_version() {}
inline const std::string& SystemProfileProto::log_written_by_app_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_log_written_by_app_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_log_written_by_app_version() {}
inline const std::string& SystemProfileProto::_internal_log_written_by_app_version() const {}
inline void SystemProfileProto::_internal_set_log_written_by_app_version(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_log_written_by_app_version() {}
inline std::string* SystemProfileProto::release_log_written_by_app_version() {}
inline void SystemProfileProto::set_allocated_log_written_by_app_version(std::string* log_written_by_app_version) {}

// optional string brand_code = 12;
inline bool SystemProfileProto::_internal_has_brand_code() const {}
inline bool SystemProfileProto::has_brand_code() const {}
inline void SystemProfileProto::clear_brand_code() {}
inline const std::string& SystemProfileProto::brand_code() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_brand_code(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_brand_code() {}
inline const std::string& SystemProfileProto::_internal_brand_code() const {}
inline void SystemProfileProto::_internal_set_brand_code(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_brand_code() {}
inline std::string* SystemProfileProto::release_brand_code() {}
inline void SystemProfileProto::set_allocated_brand_code(std::string* brand_code) {}

// optional .metrics.SystemProfileProto.Channel channel = 10;
inline bool SystemProfileProto::_internal_has_channel() const {}
inline bool SystemProfileProto::has_channel() const {}
inline void SystemProfileProto::clear_channel() {}
inline ::metrics::SystemProfileProto_Channel SystemProfileProto::_internal_channel() const {}
inline ::metrics::SystemProfileProto_Channel SystemProfileProto::channel() const {}
inline void SystemProfileProto::_internal_set_channel(::metrics::SystemProfileProto_Channel value) {}
inline void SystemProfileProto::set_channel(::metrics::SystemProfileProto_Channel value) {}

// optional bool is_extended_stable_channel = 36 [default = false];
inline bool SystemProfileProto::_internal_has_is_extended_stable_channel() const {}
inline bool SystemProfileProto::has_is_extended_stable_channel() const {}
inline void SystemProfileProto::clear_is_extended_stable_channel() {}
inline bool SystemProfileProto::_internal_is_extended_stable_channel() const {}
inline bool SystemProfileProto::is_extended_stable_channel() const {}
inline void SystemProfileProto::_internal_set_is_extended_stable_channel(bool value) {}
inline void SystemProfileProto::set_is_extended_stable_channel(bool value) {}

// optional bool is_instrumented_build = 20 [default = false];
inline bool SystemProfileProto::_internal_has_is_instrumented_build() const {}
inline bool SystemProfileProto::has_is_instrumented_build() const {}
inline void SystemProfileProto::clear_is_instrumented_build() {}
inline bool SystemProfileProto::_internal_is_instrumented_build() const {}
inline bool SystemProfileProto::is_instrumented_build() const {}
inline void SystemProfileProto::_internal_set_is_instrumented_build(bool value) {}
inline void SystemProfileProto::set_is_instrumented_build(bool value) {}

// optional int64 uma_enabled_date = 3;
inline bool SystemProfileProto::_internal_has_uma_enabled_date() const {}
inline bool SystemProfileProto::has_uma_enabled_date() const {}
inline void SystemProfileProto::clear_uma_enabled_date() {}
inline int64_t SystemProfileProto::_internal_uma_enabled_date() const {}
inline int64_t SystemProfileProto::uma_enabled_date() const {}
inline void SystemProfileProto::_internal_set_uma_enabled_date(int64_t value) {}
inline void SystemProfileProto::set_uma_enabled_date(int64_t value) {}

// optional int64 install_date = 16;
inline bool SystemProfileProto::_internal_has_install_date() const {}
inline bool SystemProfileProto::has_install_date() const {}
inline void SystemProfileProto::clear_install_date() {}
inline int64_t SystemProfileProto::_internal_install_date() const {}
inline int64_t SystemProfileProto::install_date() const {}
inline void SystemProfileProto::_internal_set_install_date(int64_t value) {}
inline void SystemProfileProto::set_install_date(int64_t value) {}

// optional .metrics.SystemProfileProto.ClonedInstallInfo cloned_install_info = 39;
inline bool SystemProfileProto::_internal_has_cloned_install_info() const {}
inline bool SystemProfileProto::has_cloned_install_info() const {}
inline void SystemProfileProto::clear_cloned_install_info() {}
inline const ::metrics::SystemProfileProto_ClonedInstallInfo& SystemProfileProto::_internal_cloned_install_info() const {}
inline const ::metrics::SystemProfileProto_ClonedInstallInfo& SystemProfileProto::cloned_install_info() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_cloned_install_info(
    ::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info) {}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::release_cloned_install_info() {}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::unsafe_arena_release_cloned_install_info() {}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::_internal_mutable_cloned_install_info() {}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::mutable_cloned_install_info() {}
inline void SystemProfileProto::set_allocated_cloned_install_info(::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info) {}

// optional int32 low_entropy_source = 31;
inline bool SystemProfileProto::_internal_has_low_entropy_source() const {}
inline bool SystemProfileProto::has_low_entropy_source() const {}
inline void SystemProfileProto::clear_low_entropy_source() {}
inline int32_t SystemProfileProto::_internal_low_entropy_source() const {}
inline int32_t SystemProfileProto::low_entropy_source() const {}
inline void SystemProfileProto::_internal_set_low_entropy_source(int32_t value) {}
inline void SystemProfileProto::set_low_entropy_source(int32_t value) {}

// optional int32 old_low_entropy_source = 32;
inline bool SystemProfileProto::_internal_has_old_low_entropy_source() const {}
inline bool SystemProfileProto::has_old_low_entropy_source() const {}
inline void SystemProfileProto::clear_old_low_entropy_source() {}
inline int32_t SystemProfileProto::_internal_old_low_entropy_source() const {}
inline int32_t SystemProfileProto::old_low_entropy_source() const {}
inline void SystemProfileProto::_internal_set_old_low_entropy_source(int32_t value) {}
inline void SystemProfileProto::set_old_low_entropy_source(int32_t value) {}

// optional int32 pseudo_low_entropy_source = 37;
inline bool SystemProfileProto::_internal_has_pseudo_low_entropy_source() const {}
inline bool SystemProfileProto::has_pseudo_low_entropy_source() const {}
inline void SystemProfileProto::clear_pseudo_low_entropy_source() {}
inline int32_t SystemProfileProto::_internal_pseudo_low_entropy_source() const {}
inline int32_t SystemProfileProto::pseudo_low_entropy_source() const {}
inline void SystemProfileProto::_internal_set_pseudo_low_entropy_source(int32_t value) {}
inline void SystemProfileProto::set_pseudo_low_entropy_source(int32_t value) {}

// optional string application_locale = 4;
inline bool SystemProfileProto::_internal_has_application_locale() const {}
inline bool SystemProfileProto::has_application_locale() const {}
inline void SystemProfileProto::clear_application_locale() {}
inline const std::string& SystemProfileProto::application_locale() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_application_locale(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_application_locale() {}
inline const std::string& SystemProfileProto::_internal_application_locale() const {}
inline void SystemProfileProto::_internal_set_application_locale(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_application_locale() {}
inline std::string* SystemProfileProto::release_application_locale() {}
inline void SystemProfileProto::set_allocated_application_locale(std::string* application_locale) {}

// repeated fixed32 command_line_key_hash = 38 [packed = true];
inline int SystemProfileProto::_internal_command_line_key_hash_size() const {}
inline int SystemProfileProto::command_line_key_hash_size() const {}
inline void SystemProfileProto::clear_command_line_key_hash() {}
inline uint32_t SystemProfileProto::_internal_command_line_key_hash(int index) const {}
inline uint32_t SystemProfileProto::command_line_key_hash(int index) const {}
inline void SystemProfileProto::set_command_line_key_hash(int index, uint32_t value) {}
inline void SystemProfileProto::_internal_add_command_line_key_hash(uint32_t value) {}
inline void SystemProfileProto::add_command_line_key_hash(uint32_t value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SystemProfileProto::_internal_command_line_key_hash() const {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SystemProfileProto::command_line_key_hash() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SystemProfileProto::_internal_mutable_command_line_key_hash() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SystemProfileProto::mutable_command_line_key_hash() {}

// optional .metrics.SystemProfileProto.OS os = 5;
inline bool SystemProfileProto::_internal_has_os() const {}
inline bool SystemProfileProto::has_os() const {}
inline void SystemProfileProto::clear_os() {}
inline const ::metrics::SystemProfileProto_OS& SystemProfileProto::_internal_os() const {}
inline const ::metrics::SystemProfileProto_OS& SystemProfileProto::os() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_os(
    ::metrics::SystemProfileProto_OS* os) {}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::release_os() {}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::unsafe_arena_release_os() {}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::_internal_mutable_os() {}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::mutable_os() {}
inline void SystemProfileProto::set_allocated_os(::metrics::SystemProfileProto_OS* os) {}

// optional .metrics.SystemProfileProto.Hardware hardware = 6;
inline bool SystemProfileProto::_internal_has_hardware() const {}
inline bool SystemProfileProto::has_hardware() const {}
inline void SystemProfileProto::clear_hardware() {}
inline const ::metrics::SystemProfileProto_Hardware& SystemProfileProto::_internal_hardware() const {}
inline const ::metrics::SystemProfileProto_Hardware& SystemProfileProto::hardware() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_hardware(
    ::metrics::SystemProfileProto_Hardware* hardware) {}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::release_hardware() {}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::unsafe_arena_release_hardware() {}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::_internal_mutable_hardware() {}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::mutable_hardware() {}
inline void SystemProfileProto::set_allocated_hardware(::metrics::SystemProfileProto_Hardware* hardware) {}

// optional .metrics.SystemProfileProto.Network network = 13;
inline bool SystemProfileProto::_internal_has_network() const {}
inline bool SystemProfileProto::has_network() const {}
inline void SystemProfileProto::clear_network() {}
inline const ::metrics::SystemProfileProto_Network& SystemProfileProto::_internal_network() const {}
inline const ::metrics::SystemProfileProto_Network& SystemProfileProto::network() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_network(
    ::metrics::SystemProfileProto_Network* network) {}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::release_network() {}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::unsafe_arena_release_network() {}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::_internal_mutable_network() {}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::mutable_network() {}
inline void SystemProfileProto::set_allocated_network(::metrics::SystemProfileProto_Network* network) {}

// optional .metrics.SystemProfileProto.GoogleUpdate google_update = 11;
inline bool SystemProfileProto::_internal_has_google_update() const {}
inline bool SystemProfileProto::has_google_update() const {}
inline void SystemProfileProto::clear_google_update() {}
inline const ::metrics::SystemProfileProto_GoogleUpdate& SystemProfileProto::_internal_google_update() const {}
inline const ::metrics::SystemProfileProto_GoogleUpdate& SystemProfileProto::google_update() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_google_update(
    ::metrics::SystemProfileProto_GoogleUpdate* google_update) {}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::release_google_update() {}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::unsafe_arena_release_google_update() {}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::_internal_mutable_google_update() {}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::mutable_google_update() {}
inline void SystemProfileProto::set_allocated_google_update(::metrics::SystemProfileProto_GoogleUpdate* google_update) {}

// optional .metrics.SystemProfileProto.Stability stability = 8;
inline bool SystemProfileProto::_internal_has_stability() const {}
inline bool SystemProfileProto::has_stability() const {}
inline void SystemProfileProto::clear_stability() {}
inline const ::metrics::SystemProfileProto_Stability& SystemProfileProto::_internal_stability() const {}
inline const ::metrics::SystemProfileProto_Stability& SystemProfileProto::stability() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_stability(
    ::metrics::SystemProfileProto_Stability* stability) {}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::release_stability() {}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::unsafe_arena_release_stability() {}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::_internal_mutable_stability() {}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::mutable_stability() {}
inline void SystemProfileProto::set_allocated_stability(::metrics::SystemProfileProto_Stability* stability) {}

// repeated .metrics.SystemProfileProto.FieldTrial field_trial = 9;
inline int SystemProfileProto::_internal_field_trial_size() const {}
inline int SystemProfileProto::field_trial_size() const {}
inline void SystemProfileProto::clear_field_trial() {}
inline ::metrics::SystemProfileProto_FieldTrial* SystemProfileProto::mutable_field_trial(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial >*
SystemProfileProto::mutable_field_trial() {}
inline const ::metrics::SystemProfileProto_FieldTrial& SystemProfileProto::_internal_field_trial(int index) const {}
inline const ::metrics::SystemProfileProto_FieldTrial& SystemProfileProto::field_trial(int index) const {}
inline ::metrics::SystemProfileProto_FieldTrial* SystemProfileProto::_internal_add_field_trial() {}
inline ::metrics::SystemProfileProto_FieldTrial* SystemProfileProto::add_field_trial() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial >&
SystemProfileProto::field_trial() const {}

// optional string variations_seed_version = 28;
inline bool SystemProfileProto::_internal_has_variations_seed_version() const {}
inline bool SystemProfileProto::has_variations_seed_version() const {}
inline void SystemProfileProto::clear_variations_seed_version() {}
inline const std::string& SystemProfileProto::variations_seed_version() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_variations_seed_version(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_variations_seed_version() {}
inline const std::string& SystemProfileProto::_internal_variations_seed_version() const {}
inline void SystemProfileProto::_internal_set_variations_seed_version(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_variations_seed_version() {}
inline std::string* SystemProfileProto::release_variations_seed_version() {}
inline void SystemProfileProto::set_allocated_variations_seed_version(std::string* variations_seed_version) {}

// optional bool client_id_was_used_for_trial_assignment = 33;
inline bool SystemProfileProto::_internal_has_client_id_was_used_for_trial_assignment() const {}
inline bool SystemProfileProto::has_client_id_was_used_for_trial_assignment() const {}
inline void SystemProfileProto::clear_client_id_was_used_for_trial_assignment() {}
inline bool SystemProfileProto::_internal_client_id_was_used_for_trial_assignment() const {}
inline bool SystemProfileProto::client_id_was_used_for_trial_assignment() const {}
inline void SystemProfileProto::_internal_set_client_id_was_used_for_trial_assignment(bool value) {}
inline void SystemProfileProto::set_client_id_was_used_for_trial_assignment(bool value) {}

// optional string client_uuid = 34;
inline bool SystemProfileProto::_internal_has_client_uuid() const {}
inline bool SystemProfileProto::has_client_uuid() const {}
inline void SystemProfileProto::clear_client_uuid() {}
inline const std::string& SystemProfileProto::client_uuid() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_client_uuid(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_client_uuid() {}
inline const std::string& SystemProfileProto::_internal_client_uuid() const {}
inline void SystemProfileProto::_internal_set_client_uuid(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_client_uuid() {}
inline std::string* SystemProfileProto::release_client_uuid() {}
inline void SystemProfileProto::set_allocated_client_uuid(std::string* client_uuid) {}

// optional fixed64 session_hash = 46;
inline bool SystemProfileProto::_internal_has_session_hash() const {}
inline bool SystemProfileProto::has_session_hash() const {}
inline void SystemProfileProto::clear_session_hash() {}
inline uint64_t SystemProfileProto::_internal_session_hash() const {}
inline uint64_t SystemProfileProto::session_hash() const {}
inline void SystemProfileProto::_internal_set_session_hash(uint64_t value) {}
inline void SystemProfileProto::set_session_hash(uint64_t value) {}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice external_audio_video_device = 14;
inline int SystemProfileProto::_internal_external_audio_video_device_size() const {}
inline int SystemProfileProto::external_audio_video_device_size() const {}
inline void SystemProfileProto::clear_external_audio_video_device() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice* SystemProfileProto::mutable_external_audio_video_device(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice >*
SystemProfileProto::mutable_external_audio_video_device() {}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice& SystemProfileProto::_internal_external_audio_video_device(int index) const {}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice& SystemProfileProto::external_audio_video_device(int index) const {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice* SystemProfileProto::_internal_add_external_audio_video_device() {}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice* SystemProfileProto::add_external_audio_video_device() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice >&
SystemProfileProto::external_audio_video_device() const {}

// optional .metrics.SystemProfileProto.ExternalAccessPoint external_access_point = 15;
inline bool SystemProfileProto::_internal_has_external_access_point() const {}
inline bool SystemProfileProto::has_external_access_point() const {}
inline void SystemProfileProto::clear_external_access_point() {}
inline const ::metrics::SystemProfileProto_ExternalAccessPoint& SystemProfileProto::_internal_external_access_point() const {}
inline const ::metrics::SystemProfileProto_ExternalAccessPoint& SystemProfileProto::external_access_point() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_external_access_point(
    ::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point) {}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::release_external_access_point() {}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::unsafe_arena_release_external_access_point() {}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::_internal_mutable_external_access_point() {}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::mutable_external_access_point() {}
inline void SystemProfileProto::set_allocated_external_access_point(::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point) {}

// optional uint32 multi_profile_user_count = 17;
inline bool SystemProfileProto::_internal_has_multi_profile_user_count() const {}
inline bool SystemProfileProto::has_multi_profile_user_count() const {}
inline void SystemProfileProto::clear_multi_profile_user_count() {}
inline uint32_t SystemProfileProto::_internal_multi_profile_user_count() const {}
inline uint32_t SystemProfileProto::multi_profile_user_count() const {}
inline void SystemProfileProto::_internal_set_multi_profile_user_count(uint32_t value) {}
inline void SystemProfileProto::set_multi_profile_user_count(uint32_t value) {}

// repeated int32 occupied_extension_bucket = 18;
inline int SystemProfileProto::_internal_occupied_extension_bucket_size() const {}
inline int SystemProfileProto::occupied_extension_bucket_size() const {}
inline void SystemProfileProto::clear_occupied_extension_bucket() {}
inline int32_t SystemProfileProto::_internal_occupied_extension_bucket(int index) const {}
inline int32_t SystemProfileProto::occupied_extension_bucket(int index) const {}
inline void SystemProfileProto::set_occupied_extension_bucket(int index, int32_t value) {}
inline void SystemProfileProto::_internal_add_occupied_extension_bucket(int32_t value) {}
inline void SystemProfileProto::add_occupied_extension_bucket(int32_t value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto::_internal_occupied_extension_bucket() const {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto::occupied_extension_bucket() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto::_internal_mutable_occupied_extension_bucket() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto::mutable_occupied_extension_bucket() {}

// optional .metrics.SystemProfileProto.ExtensionsState offstore_extensions_state = 19;
inline bool SystemProfileProto::_internal_has_offstore_extensions_state() const {}
inline bool SystemProfileProto::has_offstore_extensions_state() const {}
inline void SystemProfileProto::clear_offstore_extensions_state() {}
inline ::metrics::SystemProfileProto_ExtensionsState SystemProfileProto::_internal_offstore_extensions_state() const {}
inline ::metrics::SystemProfileProto_ExtensionsState SystemProfileProto::offstore_extensions_state() const {}
inline void SystemProfileProto::_internal_set_offstore_extensions_state(::metrics::SystemProfileProto_ExtensionsState value) {}
inline void SystemProfileProto::set_offstore_extensions_state(::metrics::SystemProfileProto_ExtensionsState value) {}

// optional .metrics.SystemProfileProto.UmaDefaultState uma_default_state = 22;
inline bool SystemProfileProto::_internal_has_uma_default_state() const {}
inline bool SystemProfileProto::has_uma_default_state() const {}
inline void SystemProfileProto::clear_uma_default_state() {}
inline ::metrics::SystemProfileProto_UmaDefaultState SystemProfileProto::_internal_uma_default_state() const {}
inline ::metrics::SystemProfileProto_UmaDefaultState SystemProfileProto::uma_default_state() const {}
inline void SystemProfileProto::_internal_set_uma_default_state(::metrics::SystemProfileProto_UmaDefaultState value) {}
inline void SystemProfileProto::set_uma_default_state(::metrics::SystemProfileProto_UmaDefaultState value) {}

// repeated .metrics.SystemProfileProto.AntiVirusProduct antivirus_product = 23;
inline int SystemProfileProto::_internal_antivirus_product_size() const {}
inline int SystemProfileProto::antivirus_product_size() const {}
inline void SystemProfileProto::clear_antivirus_product() {}
inline ::metrics::SystemProfileProto_AntiVirusProduct* SystemProfileProto::mutable_antivirus_product(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct >*
SystemProfileProto::mutable_antivirus_product() {}
inline const ::metrics::SystemProfileProto_AntiVirusProduct& SystemProfileProto::_internal_antivirus_product(int index) const {}
inline const ::metrics::SystemProfileProto_AntiVirusProduct& SystemProfileProto::antivirus_product(int index) const {}
inline ::metrics::SystemProfileProto_AntiVirusProduct* SystemProfileProto::_internal_add_antivirus_product() {}
inline ::metrics::SystemProfileProto_AntiVirusProduct* SystemProfileProto::add_antivirus_product() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct >&
SystemProfileProto::antivirus_product() const {}

// repeated .metrics.SystemProfileProto.ChromeComponent chrome_component = 24;
inline int SystemProfileProto::_internal_chrome_component_size() const {}
inline int SystemProfileProto::chrome_component_size() const {}
inline void SystemProfileProto::clear_chrome_component() {}
inline ::metrics::SystemProfileProto_ChromeComponent* SystemProfileProto::mutable_chrome_component(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent >*
SystemProfileProto::mutable_chrome_component() {}
inline const ::metrics::SystemProfileProto_ChromeComponent& SystemProfileProto::_internal_chrome_component(int index) const {}
inline const ::metrics::SystemProfileProto_ChromeComponent& SystemProfileProto::chrome_component(int index) const {}
inline ::metrics::SystemProfileProto_ChromeComponent* SystemProfileProto::_internal_add_chrome_component() {}
inline ::metrics::SystemProfileProto_ChromeComponent* SystemProfileProto::add_chrome_component() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent >&
SystemProfileProto::chrome_component() const {}

// repeated .metrics.ExtensionInstallProto extension_install = 25;
inline int SystemProfileProto::_internal_extension_install_size() const {}
inline int SystemProfileProto::extension_install_size() const {}
inline ::metrics::ExtensionInstallProto* SystemProfileProto::mutable_extension_install(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto >*
SystemProfileProto::mutable_extension_install() {}
inline const ::metrics::ExtensionInstallProto& SystemProfileProto::_internal_extension_install(int index) const {}
inline const ::metrics::ExtensionInstallProto& SystemProfileProto::extension_install(int index) const {}
inline ::metrics::ExtensionInstallProto* SystemProfileProto::_internal_add_extension_install() {}
inline ::metrics::ExtensionInstallProto* SystemProfileProto::add_extension_install() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto >&
SystemProfileProto::extension_install() const {}

// optional string app_package_name = 26;
inline bool SystemProfileProto::_internal_has_app_package_name() const {}
inline bool SystemProfileProto::has_app_package_name() const {}
inline void SystemProfileProto::clear_app_package_name() {}
inline const std::string& SystemProfileProto::app_package_name() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_app_package_name(ArgT0&& arg0, ArgT... args) {}
inline std::string* SystemProfileProto::mutable_app_package_name() {}
inline const std::string& SystemProfileProto::_internal_app_package_name() const {}
inline void SystemProfileProto::_internal_set_app_package_name(const std::string& value) {}
inline std::string* SystemProfileProto::_internal_mutable_app_package_name() {}
inline std::string* SystemProfileProto::release_app_package_name() {}
inline void SystemProfileProto::set_allocated_app_package_name(std::string* app_package_name) {}

// optional .metrics.SystemProfileProto.AppPackageNameAllowlistFilter app_package_name_allowlist_filter = 42;
inline bool SystemProfileProto::_internal_has_app_package_name_allowlist_filter() const {}
inline bool SystemProfileProto::has_app_package_name_allowlist_filter() const {}
inline void SystemProfileProto::clear_app_package_name_allowlist_filter() {}
inline ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto::_internal_app_package_name_allowlist_filter() const {}
inline ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto::app_package_name_allowlist_filter() const {}
inline void SystemProfileProto::_internal_set_app_package_name_allowlist_filter(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter value) {}
inline void SystemProfileProto::set_app_package_name_allowlist_filter(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter value) {}

// optional .metrics.SystemProfileProto.ClientSideSamplingStatus client_side_sampling_status = 43;
inline bool SystemProfileProto::_internal_has_client_side_sampling_status() const {}
inline bool SystemProfileProto::has_client_side_sampling_status() const {}
inline void SystemProfileProto::clear_client_side_sampling_status() {}
inline ::metrics::SystemProfileProto_ClientSideSamplingStatus SystemProfileProto::_internal_client_side_sampling_status() const {}
inline ::metrics::SystemProfileProto_ClientSideSamplingStatus SystemProfileProto::client_side_sampling_status() const {}
inline void SystemProfileProto::_internal_set_client_side_sampling_status(::metrics::SystemProfileProto_ClientSideSamplingStatus value) {}
inline void SystemProfileProto::set_client_side_sampling_status(::metrics::SystemProfileProto_ClientSideSamplingStatus value) {}

// optional .metrics.SystemProfileProto.MetricsFilteringStatus metrics_filtering_status = 44;
inline bool SystemProfileProto::_internal_has_metrics_filtering_status() const {}
inline bool SystemProfileProto::has_metrics_filtering_status() const {}
inline void SystemProfileProto::clear_metrics_filtering_status() {}
inline ::metrics::SystemProfileProto_MetricsFilteringStatus SystemProfileProto::_internal_metrics_filtering_status() const {}
inline ::metrics::SystemProfileProto_MetricsFilteringStatus SystemProfileProto::metrics_filtering_status() const {}
inline void SystemProfileProto::_internal_set_metrics_filtering_status(::metrics::SystemProfileProto_MetricsFilteringStatus value) {}
inline void SystemProfileProto::set_metrics_filtering_status(::metrics::SystemProfileProto_MetricsFilteringStatus value) {}

// optional .metrics.SystemProfileProto.InstallerPackage installer_package = 35;
inline bool SystemProfileProto::_internal_has_installer_package() const {}
inline bool SystemProfileProto::has_installer_package() const {}
inline void SystemProfileProto::clear_installer_package() {}
inline ::metrics::SystemProfileProto_InstallerPackage SystemProfileProto::_internal_installer_package() const {}
inline ::metrics::SystemProfileProto_InstallerPackage SystemProfileProto::installer_package() const {}
inline void SystemProfileProto::_internal_set_installer_package(::metrics::SystemProfileProto_InstallerPackage value) {}
inline void SystemProfileProto::set_installer_package(::metrics::SystemProfileProto_InstallerPackage value) {}

// optional .metrics.SystemProfileProto.LinkedAndroidPhoneData linked_android_phone_data = 29;
inline bool SystemProfileProto::_internal_has_linked_android_phone_data() const {}
inline bool SystemProfileProto::has_linked_android_phone_data() const {}
inline void SystemProfileProto::clear_linked_android_phone_data() {}
inline const ::metrics::SystemProfileProto_LinkedAndroidPhoneData& SystemProfileProto::_internal_linked_android_phone_data() const {}
inline const ::metrics::SystemProfileProto_LinkedAndroidPhoneData& SystemProfileProto::linked_android_phone_data() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_linked_android_phone_data(
    ::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data) {}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::release_linked_android_phone_data() {}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::unsafe_arena_release_linked_android_phone_data() {}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::_internal_mutable_linked_android_phone_data() {}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::mutable_linked_android_phone_data() {}
inline void SystemProfileProto::set_allocated_linked_android_phone_data(::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data) {}

// optional .metrics.SystemProfileProto.DemoModeDimensions demo_mode_dimensions = 41;
inline bool SystemProfileProto::_internal_has_demo_mode_dimensions() const {}
inline bool SystemProfileProto::has_demo_mode_dimensions() const {}
inline void SystemProfileProto::clear_demo_mode_dimensions() {}
inline const ::metrics::SystemProfileProto_DemoModeDimensions& SystemProfileProto::_internal_demo_mode_dimensions() const {}
inline const ::metrics::SystemProfileProto_DemoModeDimensions& SystemProfileProto::demo_mode_dimensions() const {}
inline void SystemProfileProto::unsafe_arena_set_allocated_demo_mode_dimensions(
    ::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions) {}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::release_demo_mode_dimensions() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::unsafe_arena_release_demo_mode_dimensions() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::_internal_mutable_demo_mode_dimensions() {}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::mutable_demo_mode_dimensions() {}
inline void SystemProfileProto::set_allocated_demo_mode_dimensions(::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions) {}

// optional .metrics.SystemProfileProto.LTSChannel lts_channel = 45;
inline bool SystemProfileProto::_internal_has_lts_channel() const {}
inline bool SystemProfileProto::has_lts_channel() const {}
inline void SystemProfileProto::clear_lts_channel() {}
inline ::metrics::SystemProfileProto_LTSChannel SystemProfileProto::_internal_lts_channel() const {}
inline ::metrics::SystemProfileProto_LTSChannel SystemProfileProto::lts_channel() const {}
inline void SystemProfileProto::_internal_set_lts_channel(::metrics::SystemProfileProto_LTSChannel value) {}
inline void SystemProfileProto::set_lts_channel(::metrics::SystemProfileProto_LTSChannel value) {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace metrics

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::metrics::SystemProfileProto_OS_DarkModeState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_OS_XdgSessionType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_OS_XdgCurrentDesktop> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_FormFactor> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_BiosType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_TpmType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Network_ConnectionType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Network_EffectiveConnectionType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Channel> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExtensionsState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_UmaDefaultState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_AntiVirusState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ComponentId> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ClientSideSamplingStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_MetricsFilteringStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_InstallerPackage> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_LTSChannel> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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