chromium/out/Default/gen/components/reporting/proto/synced/health.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: components/reporting/proto/synced/health.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_components_2freporting_2fproto_2fsynced_2fhealth_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_components_2freporting_2fproto_2fsynced_2fhealth_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 "components/reporting/proto/synced/record_constants.pb.h"
#include "components/reporting/proto/synced/status.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_components_2freporting_2fproto_2fsynced_2fhealth_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_components_2freporting_2fproto_2fsynced_2fhealth_2eproto {};
namespace reporting {
class BlockedDestinationsUpdatedCall;
struct BlockedDestinationsUpdatedCallDefaultTypeInternal;
extern BlockedDestinationsUpdatedCallDefaultTypeInternal _BlockedDestinationsUpdatedCall_default_instance_;
class BlockedRecordCall;
struct BlockedRecordCallDefaultTypeInternal;
extern BlockedRecordCallDefaultTypeInternal _BlockedRecordCall_default_instance_;
class ConfirmRecordUploadCall;
struct ConfirmRecordUploadCallDefaultTypeInternal;
extern ConfirmRecordUploadCallDefaultTypeInternal _ConfirmRecordUploadCall_default_instance_;
class ERPHealthData;
struct ERPHealthDataDefaultTypeInternal;
extern ERPHealthDataDefaultTypeInternal _ERPHealthData_default_instance_;
class EnqueueRecordCall;
struct EnqueueRecordCallDefaultTypeInternal;
extern EnqueueRecordCallDefaultTypeInternal _EnqueueRecordCall_default_instance_;
class FlushPriorityCall;
struct FlushPriorityCallDefaultTypeInternal;
extern FlushPriorityCallDefaultTypeInternal _FlushPriorityCall_default_instance_;
class HealthDataHistory;
struct HealthDataHistoryDefaultTypeInternal;
extern HealthDataHistoryDefaultTypeInternal _HealthDataHistory_default_instance_;
class StorageDequeue;
struct StorageDequeueDefaultTypeInternal;
extern StorageDequeueDefaultTypeInternal _StorageDequeue_default_instance_;
class StorageEnqueue;
struct StorageEnqueueDefaultTypeInternal;
extern StorageEnqueueDefaultTypeInternal _StorageEnqueue_default_instance_;
class StorageQueueAction;
struct StorageQueueActionDefaultTypeInternal;
extern StorageQueueActionDefaultTypeInternal _StorageQueueAction_default_instance_;
class UploadEncryptedRecordCall;
struct UploadEncryptedRecordCallDefaultTypeInternal;
extern UploadEncryptedRecordCallDefaultTypeInternal _UploadEncryptedRecordCall_default_instance_;
class UploadGapItem;
struct UploadGapItemDefaultTypeInternal;
extern UploadGapItemDefaultTypeInternal _UploadGapItem_default_instance_;
class UploadItem;
struct UploadItemDefaultTypeInternal;
extern UploadItemDefaultTypeInternal _UploadItem_default_instance_;
class UploadRecordItem;
struct UploadRecordItemDefaultTypeInternal;
extern UploadRecordItemDefaultTypeInternal _UploadRecordItem_default_instance_;
}  // namespace reporting
PROTOBUF_NAMESPACE_OPEN
template<> ::reporting::BlockedDestinationsUpdatedCall* Arena::CreateMaybeMessage<::reporting::BlockedDestinationsUpdatedCall>(Arena*);
template<> ::reporting::BlockedRecordCall* Arena::CreateMaybeMessage<::reporting::BlockedRecordCall>(Arena*);
template<> ::reporting::ConfirmRecordUploadCall* Arena::CreateMaybeMessage<::reporting::ConfirmRecordUploadCall>(Arena*);
template<> ::reporting::ERPHealthData* Arena::CreateMaybeMessage<::reporting::ERPHealthData>(Arena*);
template<> ::reporting::EnqueueRecordCall* Arena::CreateMaybeMessage<::reporting::EnqueueRecordCall>(Arena*);
template<> ::reporting::FlushPriorityCall* Arena::CreateMaybeMessage<::reporting::FlushPriorityCall>(Arena*);
template<> ::reporting::HealthDataHistory* Arena::CreateMaybeMessage<::reporting::HealthDataHistory>(Arena*);
template<> ::reporting::StorageDequeue* Arena::CreateMaybeMessage<::reporting::StorageDequeue>(Arena*);
template<> ::reporting::StorageEnqueue* Arena::CreateMaybeMessage<::reporting::StorageEnqueue>(Arena*);
template<> ::reporting::StorageQueueAction* Arena::CreateMaybeMessage<::reporting::StorageQueueAction>(Arena*);
template<> ::reporting::UploadEncryptedRecordCall* Arena::CreateMaybeMessage<::reporting::UploadEncryptedRecordCall>(Arena*);
template<> ::reporting::UploadGapItem* Arena::CreateMaybeMessage<::reporting::UploadGapItem>(Arena*);
template<> ::reporting::UploadItem* Arena::CreateMaybeMessage<::reporting::UploadItem>(Arena*);
template<> ::reporting::UploadRecordItem* Arena::CreateMaybeMessage<::reporting::UploadRecordItem>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace reporting {

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

class StorageDequeue final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.StorageDequeue) */ {};
// -------------------------------------------------------------------

class StorageEnqueue final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.StorageEnqueue) */ {};
// -------------------------------------------------------------------

class StorageQueueAction final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.StorageQueueAction) */ {};
// -------------------------------------------------------------------

class EnqueueRecordCall final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.EnqueueRecordCall) */ {};
// -------------------------------------------------------------------

class FlushPriorityCall final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.FlushPriorityCall) */ {};
// -------------------------------------------------------------------

class UploadRecordItem final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.UploadRecordItem) */ {};
// -------------------------------------------------------------------

class UploadGapItem final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.UploadGapItem) */ {};
// -------------------------------------------------------------------

class UploadItem final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.UploadItem) */ {};
// -------------------------------------------------------------------

class UploadEncryptedRecordCall final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.UploadEncryptedRecordCall) */ {};
// -------------------------------------------------------------------

class ConfirmRecordUploadCall final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.ConfirmRecordUploadCall) */ {};
// -------------------------------------------------------------------

class BlockedRecordCall final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.BlockedRecordCall) */ {};
// -------------------------------------------------------------------

class BlockedDestinationsUpdatedCall final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.BlockedDestinationsUpdatedCall) */ {};
// -------------------------------------------------------------------

class HealthDataHistory final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:reporting.HealthDataHistory) */ {};
// -------------------------------------------------------------------

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


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

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

// optional int64 sequencing_id = 1;
inline bool StorageDequeue::_internal_has_sequencing_id() const {}
inline bool StorageDequeue::has_sequencing_id() const {}
inline void StorageDequeue::clear_sequencing_id() {}
inline int64_t StorageDequeue::_internal_sequencing_id() const {}
inline int64_t StorageDequeue::sequencing_id() const {}
inline void StorageDequeue::_internal_set_sequencing_id(int64_t value) {}
inline void StorageDequeue::set_sequencing_id(int64_t value) {}

// optional int64 records_count = 2;
inline bool StorageDequeue::_internal_has_records_count() const {}
inline bool StorageDequeue::has_records_count() const {}
inline void StorageDequeue::clear_records_count() {}
inline int64_t StorageDequeue::_internal_records_count() const {}
inline int64_t StorageDequeue::records_count() const {}
inline void StorageDequeue::_internal_set_records_count(int64_t value) {}
inline void StorageDequeue::set_records_count(int64_t value) {}

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

// StorageEnqueue

// optional int64 sequencing_id = 1;
inline bool StorageEnqueue::_internal_has_sequencing_id() const {}
inline bool StorageEnqueue::has_sequencing_id() const {}
inline void StorageEnqueue::clear_sequencing_id() {}
inline int64_t StorageEnqueue::_internal_sequencing_id() const {}
inline int64_t StorageEnqueue::sequencing_id() const {}
inline void StorageEnqueue::_internal_set_sequencing_id(int64_t value) {}
inline void StorageEnqueue::set_sequencing_id(int64_t value) {}

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

// StorageQueueAction

// .reporting.StorageDequeue storage_dequeue = 1;
inline bool StorageQueueAction::_internal_has_storage_dequeue() const {}
inline bool StorageQueueAction::has_storage_dequeue() const {}
inline void StorageQueueAction::set_has_storage_dequeue() {}
inline void StorageQueueAction::clear_storage_dequeue() {}
inline ::reporting::StorageDequeue* StorageQueueAction::release_storage_dequeue() {}
inline const ::reporting::StorageDequeue& StorageQueueAction::_internal_storage_dequeue() const {}
inline const ::reporting::StorageDequeue& StorageQueueAction::storage_dequeue() const {}
inline ::reporting::StorageDequeue* StorageQueueAction::unsafe_arena_release_storage_dequeue() {}
inline void StorageQueueAction::unsafe_arena_set_allocated_storage_dequeue(::reporting::StorageDequeue* storage_dequeue) {}
inline ::reporting::StorageDequeue* StorageQueueAction::_internal_mutable_storage_dequeue() {}
inline ::reporting::StorageDequeue* StorageQueueAction::mutable_storage_dequeue() {}

// .reporting.StorageEnqueue storage_enqueue = 2;
inline bool StorageQueueAction::_internal_has_storage_enqueue() const {}
inline bool StorageQueueAction::has_storage_enqueue() const {}
inline void StorageQueueAction::set_has_storage_enqueue() {}
inline void StorageQueueAction::clear_storage_enqueue() {}
inline ::reporting::StorageEnqueue* StorageQueueAction::release_storage_enqueue() {}
inline const ::reporting::StorageEnqueue& StorageQueueAction::_internal_storage_enqueue() const {}
inline const ::reporting::StorageEnqueue& StorageQueueAction::storage_enqueue() const {}
inline ::reporting::StorageEnqueue* StorageQueueAction::unsafe_arena_release_storage_enqueue() {}
inline void StorageQueueAction::unsafe_arena_set_allocated_storage_enqueue(::reporting::StorageEnqueue* storage_enqueue) {}
inline ::reporting::StorageEnqueue* StorageQueueAction::_internal_mutable_storage_enqueue() {}
inline ::reporting::StorageEnqueue* StorageQueueAction::mutable_storage_enqueue() {}

// optional .reporting.Priority priority = 3;
inline bool StorageQueueAction::_internal_has_priority() const {}
inline bool StorageQueueAction::has_priority() const {}
inline void StorageQueueAction::clear_priority() {}
inline ::reporting::Priority StorageQueueAction::_internal_priority() const {}
inline ::reporting::Priority StorageQueueAction::priority() const {}
inline void StorageQueueAction::_internal_set_priority(::reporting::Priority value) {}
inline void StorageQueueAction::set_priority(::reporting::Priority value) {}

// optional .reporting.StatusProto status = 4;
inline bool StorageQueueAction::_internal_has_status() const {}
inline bool StorageQueueAction::has_status() const {}
inline const ::reporting::StatusProto& StorageQueueAction::_internal_status() const {}
inline const ::reporting::StatusProto& StorageQueueAction::status() const {}
inline void StorageQueueAction::unsafe_arena_set_allocated_status(
    ::reporting::StatusProto* status) {}
inline ::reporting::StatusProto* StorageQueueAction::release_status() {}
inline ::reporting::StatusProto* StorageQueueAction::unsafe_arena_release_status() {}
inline ::reporting::StatusProto* StorageQueueAction::_internal_mutable_status() {}
inline ::reporting::StatusProto* StorageQueueAction::mutable_status() {}
inline void StorageQueueAction::set_allocated_status(::reporting::StatusProto* status) {}

inline bool StorageQueueAction::has_action() const {}
inline void StorageQueueAction::clear_has_action() {}
inline StorageQueueAction::ActionCase StorageQueueAction::action_case() const {}
// -------------------------------------------------------------------

// EnqueueRecordCall

// optional .reporting.Priority priority = 1;
inline bool EnqueueRecordCall::_internal_has_priority() const {}
inline bool EnqueueRecordCall::has_priority() const {}
inline void EnqueueRecordCall::clear_priority() {}
inline ::reporting::Priority EnqueueRecordCall::_internal_priority() const {}
inline ::reporting::Priority EnqueueRecordCall::priority() const {}
inline void EnqueueRecordCall::_internal_set_priority(::reporting::Priority value) {}
inline void EnqueueRecordCall::set_priority(::reporting::Priority value) {}

// optional .reporting.Destination destination = 2;
inline bool EnqueueRecordCall::_internal_has_destination() const {}
inline bool EnqueueRecordCall::has_destination() const {}
inline void EnqueueRecordCall::clear_destination() {}
inline ::reporting::Destination EnqueueRecordCall::_internal_destination() const {}
inline ::reporting::Destination EnqueueRecordCall::destination() const {}
inline void EnqueueRecordCall::_internal_set_destination(::reporting::Destination value) {}
inline void EnqueueRecordCall::set_destination(::reporting::Destination value) {}

// optional .reporting.StatusProto status = 3;
inline bool EnqueueRecordCall::_internal_has_status() const {}
inline bool EnqueueRecordCall::has_status() const {}
inline const ::reporting::StatusProto& EnqueueRecordCall::_internal_status() const {}
inline const ::reporting::StatusProto& EnqueueRecordCall::status() const {}
inline void EnqueueRecordCall::unsafe_arena_set_allocated_status(
    ::reporting::StatusProto* status) {}
inline ::reporting::StatusProto* EnqueueRecordCall::release_status() {}
inline ::reporting::StatusProto* EnqueueRecordCall::unsafe_arena_release_status() {}
inline ::reporting::StatusProto* EnqueueRecordCall::_internal_mutable_status() {}
inline ::reporting::StatusProto* EnqueueRecordCall::mutable_status() {}
inline void EnqueueRecordCall::set_allocated_status(::reporting::StatusProto* status) {}

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

// FlushPriorityCall

// optional .reporting.Priority priority = 1;
inline bool FlushPriorityCall::_internal_has_priority() const {}
inline bool FlushPriorityCall::has_priority() const {}
inline void FlushPriorityCall::clear_priority() {}
inline ::reporting::Priority FlushPriorityCall::_internal_priority() const {}
inline ::reporting::Priority FlushPriorityCall::priority() const {}
inline void FlushPriorityCall::_internal_set_priority(::reporting::Priority value) {}
inline void FlushPriorityCall::set_priority(::reporting::Priority value) {}

// optional .reporting.StatusProto status = 2;
inline bool FlushPriorityCall::_internal_has_status() const {}
inline bool FlushPriorityCall::has_status() const {}
inline const ::reporting::StatusProto& FlushPriorityCall::_internal_status() const {}
inline const ::reporting::StatusProto& FlushPriorityCall::status() const {}
inline void FlushPriorityCall::unsafe_arena_set_allocated_status(
    ::reporting::StatusProto* status) {}
inline ::reporting::StatusProto* FlushPriorityCall::release_status() {}
inline ::reporting::StatusProto* FlushPriorityCall::unsafe_arena_release_status() {}
inline ::reporting::StatusProto* FlushPriorityCall::_internal_mutable_status() {}
inline ::reporting::StatusProto* FlushPriorityCall::mutable_status() {}
inline void FlushPriorityCall::set_allocated_status(::reporting::StatusProto* status) {}

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

// UploadRecordItem

// optional int64 sequencing_id = 1;
inline bool UploadRecordItem::_internal_has_sequencing_id() const {}
inline bool UploadRecordItem::has_sequencing_id() const {}
inline void UploadRecordItem::clear_sequencing_id() {}
inline int64_t UploadRecordItem::_internal_sequencing_id() const {}
inline int64_t UploadRecordItem::sequencing_id() const {}
inline void UploadRecordItem::_internal_set_sequencing_id(int64_t value) {}
inline void UploadRecordItem::set_sequencing_id(int64_t value) {}

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

// UploadGapItem

// optional int64 sequencing_id = 1;
inline bool UploadGapItem::_internal_has_sequencing_id() const {}
inline bool UploadGapItem::has_sequencing_id() const {}
inline void UploadGapItem::clear_sequencing_id() {}
inline int64_t UploadGapItem::_internal_sequencing_id() const {}
inline int64_t UploadGapItem::sequencing_id() const {}
inline void UploadGapItem::_internal_set_sequencing_id(int64_t value) {}
inline void UploadGapItem::set_sequencing_id(int64_t value) {}

// optional int64 count = 2;
inline bool UploadGapItem::_internal_has_count() const {}
inline bool UploadGapItem::has_count() const {}
inline void UploadGapItem::clear_count() {}
inline int64_t UploadGapItem::_internal_count() const {}
inline int64_t UploadGapItem::count() const {}
inline void UploadGapItem::_internal_set_count(int64_t value) {}
inline void UploadGapItem::set_count(int64_t value) {}

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

// UploadItem

// .reporting.UploadRecordItem record = 1;
inline bool UploadItem::_internal_has_record() const {}
inline bool UploadItem::has_record() const {}
inline void UploadItem::set_has_record() {}
inline void UploadItem::clear_record() {}
inline ::reporting::UploadRecordItem* UploadItem::release_record() {}
inline const ::reporting::UploadRecordItem& UploadItem::_internal_record() const {}
inline const ::reporting::UploadRecordItem& UploadItem::record() const {}
inline ::reporting::UploadRecordItem* UploadItem::unsafe_arena_release_record() {}
inline void UploadItem::unsafe_arena_set_allocated_record(::reporting::UploadRecordItem* record) {}
inline ::reporting::UploadRecordItem* UploadItem::_internal_mutable_record() {}
inline ::reporting::UploadRecordItem* UploadItem::mutable_record() {}

// .reporting.UploadGapItem gap = 2;
inline bool UploadItem::_internal_has_gap() const {}
inline bool UploadItem::has_gap() const {}
inline void UploadItem::set_has_gap() {}
inline void UploadItem::clear_gap() {}
inline ::reporting::UploadGapItem* UploadItem::release_gap() {}
inline const ::reporting::UploadGapItem& UploadItem::_internal_gap() const {}
inline const ::reporting::UploadGapItem& UploadItem::gap() const {}
inline ::reporting::UploadGapItem* UploadItem::unsafe_arena_release_gap() {}
inline void UploadItem::unsafe_arena_set_allocated_gap(::reporting::UploadGapItem* gap) {}
inline ::reporting::UploadGapItem* UploadItem::_internal_mutable_gap() {}
inline ::reporting::UploadGapItem* UploadItem::mutable_gap() {}

inline bool UploadItem::has_item() const {}
inline void UploadItem::clear_has_item() {}
inline UploadItem::ItemCase UploadItem::item_case() const {}
// -------------------------------------------------------------------

// UploadEncryptedRecordCall

// repeated .reporting.UploadItem items = 1;
inline int UploadEncryptedRecordCall::_internal_items_size() const {}
inline int UploadEncryptedRecordCall::items_size() const {}
inline void UploadEncryptedRecordCall::clear_items() {}
inline ::reporting::UploadItem* UploadEncryptedRecordCall::mutable_items(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::reporting::UploadItem >*
UploadEncryptedRecordCall::mutable_items() {}
inline const ::reporting::UploadItem& UploadEncryptedRecordCall::_internal_items(int index) const {}
inline const ::reporting::UploadItem& UploadEncryptedRecordCall::items(int index) const {}
inline ::reporting::UploadItem* UploadEncryptedRecordCall::_internal_add_items() {}
inline ::reporting::UploadItem* UploadEncryptedRecordCall::add_items() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::reporting::UploadItem >&
UploadEncryptedRecordCall::items() const {}

// optional string upload_reason = 2;
inline bool UploadEncryptedRecordCall::_internal_has_upload_reason() const {}
inline bool UploadEncryptedRecordCall::has_upload_reason() const {}
inline void UploadEncryptedRecordCall::clear_upload_reason() {}
inline const std::string& UploadEncryptedRecordCall::upload_reason() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UploadEncryptedRecordCall::set_upload_reason(ArgT0&& arg0, ArgT... args) {}
inline std::string* UploadEncryptedRecordCall::mutable_upload_reason() {}
inline const std::string& UploadEncryptedRecordCall::_internal_upload_reason() const {}
inline void UploadEncryptedRecordCall::_internal_set_upload_reason(const std::string& value) {}
inline std::string* UploadEncryptedRecordCall::_internal_mutable_upload_reason() {}
inline std::string* UploadEncryptedRecordCall::release_upload_reason() {}
inline void UploadEncryptedRecordCall::set_allocated_upload_reason(std::string* upload_reason) {}

// optional .reporting.Priority priority = 3;
inline bool UploadEncryptedRecordCall::_internal_has_priority() const {}
inline bool UploadEncryptedRecordCall::has_priority() const {}
inline void UploadEncryptedRecordCall::clear_priority() {}
inline ::reporting::Priority UploadEncryptedRecordCall::_internal_priority() const {}
inline ::reporting::Priority UploadEncryptedRecordCall::priority() const {}
inline void UploadEncryptedRecordCall::_internal_set_priority(::reporting::Priority value) {}
inline void UploadEncryptedRecordCall::set_priority(::reporting::Priority value) {}

// optional .reporting.StatusProto status = 4;
inline bool UploadEncryptedRecordCall::_internal_has_status() const {}
inline bool UploadEncryptedRecordCall::has_status() const {}
inline const ::reporting::StatusProto& UploadEncryptedRecordCall::_internal_status() const {}
inline const ::reporting::StatusProto& UploadEncryptedRecordCall::status() const {}
inline void UploadEncryptedRecordCall::unsafe_arena_set_allocated_status(
    ::reporting::StatusProto* status) {}
inline ::reporting::StatusProto* UploadEncryptedRecordCall::release_status() {}
inline ::reporting::StatusProto* UploadEncryptedRecordCall::unsafe_arena_release_status() {}
inline ::reporting::StatusProto* UploadEncryptedRecordCall::_internal_mutable_status() {}
inline ::reporting::StatusProto* UploadEncryptedRecordCall::mutable_status() {}
inline void UploadEncryptedRecordCall::set_allocated_status(::reporting::StatusProto* status) {}

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

// ConfirmRecordUploadCall

// optional int64 sequencing_id = 1;
inline bool ConfirmRecordUploadCall::_internal_has_sequencing_id() const {}
inline bool ConfirmRecordUploadCall::has_sequencing_id() const {}
inline void ConfirmRecordUploadCall::clear_sequencing_id() {}
inline int64_t ConfirmRecordUploadCall::_internal_sequencing_id() const {}
inline int64_t ConfirmRecordUploadCall::sequencing_id() const {}
inline void ConfirmRecordUploadCall::_internal_set_sequencing_id(int64_t value) {}
inline void ConfirmRecordUploadCall::set_sequencing_id(int64_t value) {}

// optional bool force_confirm = 2;
inline bool ConfirmRecordUploadCall::_internal_has_force_confirm() const {}
inline bool ConfirmRecordUploadCall::has_force_confirm() const {}
inline void ConfirmRecordUploadCall::clear_force_confirm() {}
inline bool ConfirmRecordUploadCall::_internal_force_confirm() const {}
inline bool ConfirmRecordUploadCall::force_confirm() const {}
inline void ConfirmRecordUploadCall::_internal_set_force_confirm(bool value) {}
inline void ConfirmRecordUploadCall::set_force_confirm(bool value) {}

// optional .reporting.Priority priority = 3;
inline bool ConfirmRecordUploadCall::_internal_has_priority() const {}
inline bool ConfirmRecordUploadCall::has_priority() const {}
inline void ConfirmRecordUploadCall::clear_priority() {}
inline ::reporting::Priority ConfirmRecordUploadCall::_internal_priority() const {}
inline ::reporting::Priority ConfirmRecordUploadCall::priority() const {}
inline void ConfirmRecordUploadCall::_internal_set_priority(::reporting::Priority value) {}
inline void ConfirmRecordUploadCall::set_priority(::reporting::Priority value) {}

// optional .reporting.StatusProto status = 4;
inline bool ConfirmRecordUploadCall::_internal_has_status() const {}
inline bool ConfirmRecordUploadCall::has_status() const {}
inline const ::reporting::StatusProto& ConfirmRecordUploadCall::_internal_status() const {}
inline const ::reporting::StatusProto& ConfirmRecordUploadCall::status() const {}
inline void ConfirmRecordUploadCall::unsafe_arena_set_allocated_status(
    ::reporting::StatusProto* status) {}
inline ::reporting::StatusProto* ConfirmRecordUploadCall::release_status() {}
inline ::reporting::StatusProto* ConfirmRecordUploadCall::unsafe_arena_release_status() {}
inline ::reporting::StatusProto* ConfirmRecordUploadCall::_internal_mutable_status() {}
inline ::reporting::StatusProto* ConfirmRecordUploadCall::mutable_status() {}
inline void ConfirmRecordUploadCall::set_allocated_status(::reporting::StatusProto* status) {}

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

// BlockedRecordCall

// optional .reporting.Priority priority = 1;
inline bool BlockedRecordCall::_internal_has_priority() const {}
inline bool BlockedRecordCall::has_priority() const {}
inline void BlockedRecordCall::clear_priority() {}
inline ::reporting::Priority BlockedRecordCall::_internal_priority() const {}
inline ::reporting::Priority BlockedRecordCall::priority() const {}
inline void BlockedRecordCall::_internal_set_priority(::reporting::Priority value) {}
inline void BlockedRecordCall::set_priority(::reporting::Priority value) {}

// optional .reporting.Destination destination = 2;
inline bool BlockedRecordCall::_internal_has_destination() const {}
inline bool BlockedRecordCall::has_destination() const {}
inline void BlockedRecordCall::clear_destination() {}
inline ::reporting::Destination BlockedRecordCall::_internal_destination() const {}
inline ::reporting::Destination BlockedRecordCall::destination() const {}
inline void BlockedRecordCall::_internal_set_destination(::reporting::Destination value) {}
inline void BlockedRecordCall::set_destination(::reporting::Destination value) {}

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

// BlockedDestinationsUpdatedCall

// repeated .reporting.Destination destinations = 1;
inline int BlockedDestinationsUpdatedCall::_internal_destinations_size() const {}
inline int BlockedDestinationsUpdatedCall::destinations_size() const {}
inline void BlockedDestinationsUpdatedCall::clear_destinations() {}
inline ::reporting::Destination BlockedDestinationsUpdatedCall::_internal_destinations(int index) const {}
inline ::reporting::Destination BlockedDestinationsUpdatedCall::destinations(int index) const {}
inline void BlockedDestinationsUpdatedCall::set_destinations(int index, ::reporting::Destination value) {}
inline void BlockedDestinationsUpdatedCall::_internal_add_destinations(::reporting::Destination value) {}
inline void BlockedDestinationsUpdatedCall::add_destinations(::reporting::Destination value) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
BlockedDestinationsUpdatedCall::destinations() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
BlockedDestinationsUpdatedCall::_internal_mutable_destinations() {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
BlockedDestinationsUpdatedCall::mutable_destinations() {}

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

// HealthDataHistory

// .reporting.EnqueueRecordCall enqueue_record_call = 1;
inline bool HealthDataHistory::_internal_has_enqueue_record_call() const {}
inline bool HealthDataHistory::has_enqueue_record_call() const {}
inline void HealthDataHistory::set_has_enqueue_record_call() {}
inline void HealthDataHistory::clear_enqueue_record_call() {}
inline ::reporting::EnqueueRecordCall* HealthDataHistory::release_enqueue_record_call() {}
inline const ::reporting::EnqueueRecordCall& HealthDataHistory::_internal_enqueue_record_call() const {}
inline const ::reporting::EnqueueRecordCall& HealthDataHistory::enqueue_record_call() const {}
inline ::reporting::EnqueueRecordCall* HealthDataHistory::unsafe_arena_release_enqueue_record_call() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_enqueue_record_call(::reporting::EnqueueRecordCall* enqueue_record_call) {}
inline ::reporting::EnqueueRecordCall* HealthDataHistory::_internal_mutable_enqueue_record_call() {}
inline ::reporting::EnqueueRecordCall* HealthDataHistory::mutable_enqueue_record_call() {}

// .reporting.FlushPriorityCall flush_priority_call = 2;
inline bool HealthDataHistory::_internal_has_flush_priority_call() const {}
inline bool HealthDataHistory::has_flush_priority_call() const {}
inline void HealthDataHistory::set_has_flush_priority_call() {}
inline void HealthDataHistory::clear_flush_priority_call() {}
inline ::reporting::FlushPriorityCall* HealthDataHistory::release_flush_priority_call() {}
inline const ::reporting::FlushPriorityCall& HealthDataHistory::_internal_flush_priority_call() const {}
inline const ::reporting::FlushPriorityCall& HealthDataHistory::flush_priority_call() const {}
inline ::reporting::FlushPriorityCall* HealthDataHistory::unsafe_arena_release_flush_priority_call() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_flush_priority_call(::reporting::FlushPriorityCall* flush_priority_call) {}
inline ::reporting::FlushPriorityCall* HealthDataHistory::_internal_mutable_flush_priority_call() {}
inline ::reporting::FlushPriorityCall* HealthDataHistory::mutable_flush_priority_call() {}

// .reporting.UploadEncryptedRecordCall upload_encrypted_record_call = 3;
inline bool HealthDataHistory::_internal_has_upload_encrypted_record_call() const {}
inline bool HealthDataHistory::has_upload_encrypted_record_call() const {}
inline void HealthDataHistory::set_has_upload_encrypted_record_call() {}
inline void HealthDataHistory::clear_upload_encrypted_record_call() {}
inline ::reporting::UploadEncryptedRecordCall* HealthDataHistory::release_upload_encrypted_record_call() {}
inline const ::reporting::UploadEncryptedRecordCall& HealthDataHistory::_internal_upload_encrypted_record_call() const {}
inline const ::reporting::UploadEncryptedRecordCall& HealthDataHistory::upload_encrypted_record_call() const {}
inline ::reporting::UploadEncryptedRecordCall* HealthDataHistory::unsafe_arena_release_upload_encrypted_record_call() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_upload_encrypted_record_call(::reporting::UploadEncryptedRecordCall* upload_encrypted_record_call) {}
inline ::reporting::UploadEncryptedRecordCall* HealthDataHistory::_internal_mutable_upload_encrypted_record_call() {}
inline ::reporting::UploadEncryptedRecordCall* HealthDataHistory::mutable_upload_encrypted_record_call() {}

// .reporting.ConfirmRecordUploadCall confirm_record_upload_call = 4;
inline bool HealthDataHistory::_internal_has_confirm_record_upload_call() const {}
inline bool HealthDataHistory::has_confirm_record_upload_call() const {}
inline void HealthDataHistory::set_has_confirm_record_upload_call() {}
inline void HealthDataHistory::clear_confirm_record_upload_call() {}
inline ::reporting::ConfirmRecordUploadCall* HealthDataHistory::release_confirm_record_upload_call() {}
inline const ::reporting::ConfirmRecordUploadCall& HealthDataHistory::_internal_confirm_record_upload_call() const {}
inline const ::reporting::ConfirmRecordUploadCall& HealthDataHistory::confirm_record_upload_call() const {}
inline ::reporting::ConfirmRecordUploadCall* HealthDataHistory::unsafe_arena_release_confirm_record_upload_call() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_confirm_record_upload_call(::reporting::ConfirmRecordUploadCall* confirm_record_upload_call) {}
inline ::reporting::ConfirmRecordUploadCall* HealthDataHistory::_internal_mutable_confirm_record_upload_call() {}
inline ::reporting::ConfirmRecordUploadCall* HealthDataHistory::mutable_confirm_record_upload_call() {}

// .reporting.StorageQueueAction storage_queue_action = 5;
inline bool HealthDataHistory::_internal_has_storage_queue_action() const {}
inline bool HealthDataHistory::has_storage_queue_action() const {}
inline void HealthDataHistory::set_has_storage_queue_action() {}
inline void HealthDataHistory::clear_storage_queue_action() {}
inline ::reporting::StorageQueueAction* HealthDataHistory::release_storage_queue_action() {}
inline const ::reporting::StorageQueueAction& HealthDataHistory::_internal_storage_queue_action() const {}
inline const ::reporting::StorageQueueAction& HealthDataHistory::storage_queue_action() const {}
inline ::reporting::StorageQueueAction* HealthDataHistory::unsafe_arena_release_storage_queue_action() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_storage_queue_action(::reporting::StorageQueueAction* storage_queue_action) {}
inline ::reporting::StorageQueueAction* HealthDataHistory::_internal_mutable_storage_queue_action() {}
inline ::reporting::StorageQueueAction* HealthDataHistory::mutable_storage_queue_action() {}

// .reporting.BlockedRecordCall blocked_record_call = 7;
inline bool HealthDataHistory::_internal_has_blocked_record_call() const {}
inline bool HealthDataHistory::has_blocked_record_call() const {}
inline void HealthDataHistory::set_has_blocked_record_call() {}
inline void HealthDataHistory::clear_blocked_record_call() {}
inline ::reporting::BlockedRecordCall* HealthDataHistory::release_blocked_record_call() {}
inline const ::reporting::BlockedRecordCall& HealthDataHistory::_internal_blocked_record_call() const {}
inline const ::reporting::BlockedRecordCall& HealthDataHistory::blocked_record_call() const {}
inline ::reporting::BlockedRecordCall* HealthDataHistory::unsafe_arena_release_blocked_record_call() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_blocked_record_call(::reporting::BlockedRecordCall* blocked_record_call) {}
inline ::reporting::BlockedRecordCall* HealthDataHistory::_internal_mutable_blocked_record_call() {}
inline ::reporting::BlockedRecordCall* HealthDataHistory::mutable_blocked_record_call() {}

// .reporting.BlockedDestinationsUpdatedCall blocked_destinations_updated_call = 8;
inline bool HealthDataHistory::_internal_has_blocked_destinations_updated_call() const {}
inline bool HealthDataHistory::has_blocked_destinations_updated_call() const {}
inline void HealthDataHistory::set_has_blocked_destinations_updated_call() {}
inline void HealthDataHistory::clear_blocked_destinations_updated_call() {}
inline ::reporting::BlockedDestinationsUpdatedCall* HealthDataHistory::release_blocked_destinations_updated_call() {}
inline const ::reporting::BlockedDestinationsUpdatedCall& HealthDataHistory::_internal_blocked_destinations_updated_call() const {}
inline const ::reporting::BlockedDestinationsUpdatedCall& HealthDataHistory::blocked_destinations_updated_call() const {}
inline ::reporting::BlockedDestinationsUpdatedCall* HealthDataHistory::unsafe_arena_release_blocked_destinations_updated_call() {}
inline void HealthDataHistory::unsafe_arena_set_allocated_blocked_destinations_updated_call(::reporting::BlockedDestinationsUpdatedCall* blocked_destinations_updated_call) {}
inline ::reporting::BlockedDestinationsUpdatedCall* HealthDataHistory::_internal_mutable_blocked_destinations_updated_call() {}
inline ::reporting::BlockedDestinationsUpdatedCall* HealthDataHistory::mutable_blocked_destinations_updated_call() {}

// optional int64 timestamp_seconds = 6;
inline bool HealthDataHistory::_internal_has_timestamp_seconds() const {}
inline bool HealthDataHistory::has_timestamp_seconds() const {}
inline void HealthDataHistory::clear_timestamp_seconds() {}
inline int64_t HealthDataHistory::_internal_timestamp_seconds() const {}
inline int64_t HealthDataHistory::timestamp_seconds() const {}
inline void HealthDataHistory::_internal_set_timestamp_seconds(int64_t value) {}
inline void HealthDataHistory::set_timestamp_seconds(int64_t value) {}

inline bool HealthDataHistory::has_record() const {}
inline void HealthDataHistory::clear_has_record() {}
inline HealthDataHistory::RecordCase HealthDataHistory::record_case() const {}
// -------------------------------------------------------------------

// ERPHealthData

// repeated .reporting.HealthDataHistory history = 1;
inline int ERPHealthData::_internal_history_size() const {}
inline int ERPHealthData::history_size() const {}
inline void ERPHealthData::clear_history() {}
inline ::reporting::HealthDataHistory* ERPHealthData::mutable_history(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::reporting::HealthDataHistory >*
ERPHealthData::mutable_history() {}
inline const ::reporting::HealthDataHistory& ERPHealthData::_internal_history(int index) const {}
inline const ::reporting::HealthDataHistory& ERPHealthData::history(int index) const {}
inline ::reporting::HealthDataHistory* ERPHealthData::_internal_add_history() {}
inline ::reporting::HealthDataHistory* ERPHealthData::add_history() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::reporting::HealthDataHistory >&
ERPHealthData::history() const {}

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace reporting

// @@protoc_insertion_point(global_scope)

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