chromium/out/Default/gen/device/fido/enclave/verify/proto/expected_value.pb.cc

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

#include "expected_value.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace device {
namespace enclave {
PROTOBUF_CONSTEXPR VerificationSkipped::VerificationSkipped(
    ::_pbi::ConstantInitialized): … { … }
struct VerificationSkippedDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerificationSkippedDefaultTypeInternal _VerificationSkipped_default_instance_;
PROTOBUF_CONSTEXPR RawDigests::RawDigests(
    ::_pbi::ConstantInitialized): … { … }
struct RawDigestsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RawDigestsDefaultTypeInternal _RawDigests_default_instance_;
PROTOBUF_CONSTEXPR ExpectedDigests::ExpectedDigests(
    ::_pbi::ConstantInitialized): … { … }
struct ExpectedDigestsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExpectedDigestsDefaultTypeInternal _ExpectedDigests_default_instance_;
PROTOBUF_CONSTEXPR KernelExpectedValues::KernelExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct KernelExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KernelExpectedValuesDefaultTypeInternal _KernelExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR AmdSevExpectedValues::AmdSevExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct AmdSevExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AmdSevExpectedValuesDefaultTypeInternal _AmdSevExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR IntelTdxExpectedValues::IntelTdxExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct IntelTdxExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IntelTdxExpectedValuesDefaultTypeInternal _IntelTdxExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR InsecureExpectedValues::InsecureExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct InsecureExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InsecureExpectedValuesDefaultTypeInternal _InsecureExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR ExpectedRegex::ExpectedRegex(
    ::_pbi::ConstantInitialized): … { … }
struct ExpectedRegexDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExpectedRegexDefaultTypeInternal _ExpectedRegex_default_instance_;
PROTOBUF_CONSTEXPR ExpectedStringLiterals::ExpectedStringLiterals(
    ::_pbi::ConstantInitialized): … { … }
struct ExpectedStringLiteralsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExpectedStringLiteralsDefaultTypeInternal _ExpectedStringLiterals_default_instance_;
PROTOBUF_CONSTEXPR TextExpectedValue::TextExpectedValue(
    ::_pbi::ConstantInitialized): … { … }
struct TextExpectedValueDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TextExpectedValueDefaultTypeInternal _TextExpectedValue_default_instance_;
PROTOBUF_CONSTEXPR RootLayerExpectedValues::RootLayerExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct RootLayerExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RootLayerExpectedValuesDefaultTypeInternal _RootLayerExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR KernelLayerExpectedValues::KernelLayerExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct KernelLayerExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KernelLayerExpectedValuesDefaultTypeInternal _KernelLayerExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR SystemLayerExpectedValues::SystemLayerExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct SystemLayerExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SystemLayerExpectedValuesDefaultTypeInternal _SystemLayerExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR ContainerLayerExpectedValues::ContainerLayerExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct ContainerLayerExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContainerLayerExpectedValuesDefaultTypeInternal _ContainerLayerExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR ApplicationLayerExpectedValues::ApplicationLayerExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct ApplicationLayerExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ApplicationLayerExpectedValuesDefaultTypeInternal _ApplicationLayerExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR OakRestrictedKernelExpectedValues::OakRestrictedKernelExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct OakRestrictedKernelExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OakRestrictedKernelExpectedValuesDefaultTypeInternal _OakRestrictedKernelExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR OakContainersExpectedValues::OakContainersExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct OakContainersExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OakContainersExpectedValuesDefaultTypeInternal _OakContainersExpectedValues_default_instance_;
PROTOBUF_CONSTEXPR ExpectedValues::ExpectedValues(
    ::_pbi::ConstantInitialized): … { … }
struct ExpectedValuesDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExpectedValuesDefaultTypeInternal _ExpectedValues_default_instance_;
}  // namespace enclave
}  // namespace device
namespace device {
namespace enclave {

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

class VerificationSkipped::_Internal { … };

VerificationSkipped::VerificationSkipped(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
VerificationSkipped::VerificationSkipped(const VerificationSkipped& from)
  : … { … }

inline void VerificationSkipped::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

VerificationSkipped::~VerificationSkipped() { … }

inline void VerificationSkipped::SharedDtor() { … }

void VerificationSkipped::SetCachedSize(int size) const { … }

void VerificationSkipped::Clear() { … }

const char* VerificationSkipped::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* VerificationSkipped::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t VerificationSkipped::ByteSizeLong() const { … }

void VerificationSkipped::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void VerificationSkipped::MergeFrom(const VerificationSkipped& from) { … }

void VerificationSkipped::CopyFrom(const VerificationSkipped& from) { … }

bool VerificationSkipped::IsInitialized() const { … }

void VerificationSkipped::InternalSwap(VerificationSkipped* other) { … }

std::string VerificationSkipped::GetTypeName() const { … }


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

class RawDigests::_Internal { … };

void RawDigests::clear_digests() { … }
RawDigests::RawDigests(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RawDigests::RawDigests(const RawDigests& from)
  : … { … }

inline void RawDigests::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RawDigests::~RawDigests() { … }

inline void RawDigests::SharedDtor() { … }

void RawDigests::SetCachedSize(int size) const { … }

void RawDigests::Clear() { … }

const char* RawDigests::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RawDigests::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RawDigests::ByteSizeLong() const { … }

void RawDigests::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RawDigests::MergeFrom(const RawDigests& from) { … }

void RawDigests::CopyFrom(const RawDigests& from) { … }

bool RawDigests::IsInitialized() const { … }

void RawDigests::InternalSwap(RawDigests* other) { … }

std::string RawDigests::GetTypeName() const { … }


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

class ExpectedDigests::_Internal { … };

const ::device::enclave::VerificationSkipped&
ExpectedDigests::_Internal::skipped(const ExpectedDigests* msg) { … }
const ::device::enclave::RawDigests&
ExpectedDigests::_Internal::digests(const ExpectedDigests* msg) { … }
void ExpectedDigests::set_allocated_skipped(::device::enclave::VerificationSkipped* skipped) { … }
void ExpectedDigests::set_allocated_digests(::device::enclave::RawDigests* digests) { … }
ExpectedDigests::ExpectedDigests(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ExpectedDigests::ExpectedDigests(const ExpectedDigests& from)
  : … { … }

inline void ExpectedDigests::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ExpectedDigests::~ExpectedDigests() { … }

inline void ExpectedDigests::SharedDtor() { … }

void ExpectedDigests::SetCachedSize(int size) const { … }

void ExpectedDigests::clear_type() { … }


void ExpectedDigests::Clear() { … }

const char* ExpectedDigests::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ExpectedDigests::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ExpectedDigests::ByteSizeLong() const { … }

void ExpectedDigests::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ExpectedDigests::MergeFrom(const ExpectedDigests& from) { … }

void ExpectedDigests::CopyFrom(const ExpectedDigests& from) { … }

bool ExpectedDigests::IsInitialized() const { … }

void ExpectedDigests::InternalSwap(ExpectedDigests* other) { … }

std::string ExpectedDigests::GetTypeName() const { … }


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

class KernelExpectedValues::_Internal { … };

const ::device::enclave::ExpectedDigests&
KernelExpectedValues::_Internal::image(const KernelExpectedValues* msg) { … }
const ::device::enclave::ExpectedDigests&
KernelExpectedValues::_Internal::setup_data(const KernelExpectedValues* msg) { … }
KernelExpectedValues::KernelExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
KernelExpectedValues::KernelExpectedValues(const KernelExpectedValues& from)
  : … { … }

inline void KernelExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

KernelExpectedValues::~KernelExpectedValues() { … }

inline void KernelExpectedValues::SharedDtor() { … }

void KernelExpectedValues::SetCachedSize(int size) const { … }

void KernelExpectedValues::Clear() { … }

const char* KernelExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* KernelExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t KernelExpectedValues::ByteSizeLong() const { … }

void KernelExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void KernelExpectedValues::MergeFrom(const KernelExpectedValues& from) { … }

void KernelExpectedValues::CopyFrom(const KernelExpectedValues& from) { … }

bool KernelExpectedValues::IsInitialized() const { … }

void KernelExpectedValues::InternalSwap(KernelExpectedValues* other) { … }

std::string KernelExpectedValues::GetTypeName() const { … }


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

class AmdSevExpectedValues::_Internal { … };

const ::device::enclave::ExpectedDigests&
AmdSevExpectedValues::_Internal::stage0_expected(const AmdSevExpectedValues* msg) { … }
const ::device::enclave::TcbVersion&
AmdSevExpectedValues::_Internal::min_tcb_version(const AmdSevExpectedValues* msg) { … }
void AmdSevExpectedValues::clear_min_tcb_version() { … }
AmdSevExpectedValues::AmdSevExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AmdSevExpectedValues::AmdSevExpectedValues(const AmdSevExpectedValues& from)
  : … { … }

inline void AmdSevExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AmdSevExpectedValues::~AmdSevExpectedValues() { … }

inline void AmdSevExpectedValues::SharedDtor() { … }

void AmdSevExpectedValues::SetCachedSize(int size) const { … }

void AmdSevExpectedValues::Clear() { … }

const char* AmdSevExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AmdSevExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AmdSevExpectedValues::ByteSizeLong() const { … }

void AmdSevExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AmdSevExpectedValues::MergeFrom(const AmdSevExpectedValues& from) { … }

void AmdSevExpectedValues::CopyFrom(const AmdSevExpectedValues& from) { … }

bool AmdSevExpectedValues::IsInitialized() const { … }

void AmdSevExpectedValues::InternalSwap(AmdSevExpectedValues* other) { … }

std::string AmdSevExpectedValues::GetTypeName() const { … }


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

class IntelTdxExpectedValues::_Internal { … };

IntelTdxExpectedValues::IntelTdxExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
IntelTdxExpectedValues::IntelTdxExpectedValues(const IntelTdxExpectedValues& from)
  : … { … }

inline void IntelTdxExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

IntelTdxExpectedValues::~IntelTdxExpectedValues() { … }

inline void IntelTdxExpectedValues::SharedDtor() { … }

void IntelTdxExpectedValues::SetCachedSize(int size) const { … }

void IntelTdxExpectedValues::Clear() { … }

const char* IntelTdxExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* IntelTdxExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t IntelTdxExpectedValues::ByteSizeLong() const { … }

void IntelTdxExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void IntelTdxExpectedValues::MergeFrom(const IntelTdxExpectedValues& from) { … }

void IntelTdxExpectedValues::CopyFrom(const IntelTdxExpectedValues& from) { … }

bool IntelTdxExpectedValues::IsInitialized() const { … }

void IntelTdxExpectedValues::InternalSwap(IntelTdxExpectedValues* other) { … }

std::string IntelTdxExpectedValues::GetTypeName() const { … }


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

class InsecureExpectedValues::_Internal { … };

InsecureExpectedValues::InsecureExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
InsecureExpectedValues::InsecureExpectedValues(const InsecureExpectedValues& from)
  : … { … }

inline void InsecureExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

InsecureExpectedValues::~InsecureExpectedValues() { … }

inline void InsecureExpectedValues::SharedDtor() { … }

void InsecureExpectedValues::SetCachedSize(int size) const { … }

void InsecureExpectedValues::Clear() { … }

const char* InsecureExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* InsecureExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t InsecureExpectedValues::ByteSizeLong() const { … }

void InsecureExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void InsecureExpectedValues::MergeFrom(const InsecureExpectedValues& from) { … }

void InsecureExpectedValues::CopyFrom(const InsecureExpectedValues& from) { … }

bool InsecureExpectedValues::IsInitialized() const { … }

void InsecureExpectedValues::InternalSwap(InsecureExpectedValues* other) { … }

std::string InsecureExpectedValues::GetTypeName() const { … }


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

class ExpectedRegex::_Internal { … };

ExpectedRegex::ExpectedRegex(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ExpectedRegex::ExpectedRegex(const ExpectedRegex& from)
  : … { … }

inline void ExpectedRegex::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ExpectedRegex::~ExpectedRegex() { … }

inline void ExpectedRegex::SharedDtor() { … }

void ExpectedRegex::SetCachedSize(int size) const { … }

void ExpectedRegex::Clear() { … }

const char* ExpectedRegex::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ExpectedRegex::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ExpectedRegex::ByteSizeLong() const { … }

void ExpectedRegex::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ExpectedRegex::MergeFrom(const ExpectedRegex& from) { … }

void ExpectedRegex::CopyFrom(const ExpectedRegex& from) { … }

bool ExpectedRegex::IsInitialized() const { … }

void ExpectedRegex::InternalSwap(ExpectedRegex* other) { … }

std::string ExpectedRegex::GetTypeName() const { … }


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

class ExpectedStringLiterals::_Internal { … };

ExpectedStringLiterals::ExpectedStringLiterals(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ExpectedStringLiterals::ExpectedStringLiterals(const ExpectedStringLiterals& from)
  : … { … }

inline void ExpectedStringLiterals::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ExpectedStringLiterals::~ExpectedStringLiterals() { … }

inline void ExpectedStringLiterals::SharedDtor() { … }

void ExpectedStringLiterals::SetCachedSize(int size) const { … }

void ExpectedStringLiterals::Clear() { … }

const char* ExpectedStringLiterals::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ExpectedStringLiterals::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ExpectedStringLiterals::ByteSizeLong() const { … }

void ExpectedStringLiterals::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ExpectedStringLiterals::MergeFrom(const ExpectedStringLiterals& from) { … }

void ExpectedStringLiterals::CopyFrom(const ExpectedStringLiterals& from) { … }

bool ExpectedStringLiterals::IsInitialized() const { … }

void ExpectedStringLiterals::InternalSwap(ExpectedStringLiterals* other) { … }

std::string ExpectedStringLiterals::GetTypeName() const { … }


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

class TextExpectedValue::_Internal { … };

const ::device::enclave::VerificationSkipped&
TextExpectedValue::_Internal::skipped(const TextExpectedValue* msg) { … }
const ::device::enclave::ExpectedRegex&
TextExpectedValue::_Internal::regex(const TextExpectedValue* msg) { … }
const ::device::enclave::ExpectedStringLiterals&
TextExpectedValue::_Internal::string_literals(const TextExpectedValue* msg) { … }
void TextExpectedValue::set_allocated_skipped(::device::enclave::VerificationSkipped* skipped) { … }
void TextExpectedValue::set_allocated_regex(::device::enclave::ExpectedRegex* regex) { … }
void TextExpectedValue::set_allocated_string_literals(::device::enclave::ExpectedStringLiterals* string_literals) { … }
TextExpectedValue::TextExpectedValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
TextExpectedValue::TextExpectedValue(const TextExpectedValue& from)
  : … { … }

inline void TextExpectedValue::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

TextExpectedValue::~TextExpectedValue() { … }

inline void TextExpectedValue::SharedDtor() { … }

void TextExpectedValue::SetCachedSize(int size) const { … }

void TextExpectedValue::clear_type() { … }


void TextExpectedValue::Clear() { … }

const char* TextExpectedValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* TextExpectedValue::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t TextExpectedValue::ByteSizeLong() const { … }

void TextExpectedValue::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void TextExpectedValue::MergeFrom(const TextExpectedValue& from) { … }

void TextExpectedValue::CopyFrom(const TextExpectedValue& from) { … }

bool TextExpectedValue::IsInitialized() const { … }

void TextExpectedValue::InternalSwap(TextExpectedValue* other) { … }

std::string TextExpectedValue::GetTypeName() const { … }


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

class RootLayerExpectedValues::_Internal { … };

const ::device::enclave::AmdSevExpectedValues&
RootLayerExpectedValues::_Internal::amd_sev(const RootLayerExpectedValues* msg) { … }
const ::device::enclave::IntelTdxExpectedValues&
RootLayerExpectedValues::_Internal::intel_tdx(const RootLayerExpectedValues* msg) { … }
const ::device::enclave::InsecureExpectedValues&
RootLayerExpectedValues::_Internal::insecure(const RootLayerExpectedValues* msg) { … }
RootLayerExpectedValues::RootLayerExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RootLayerExpectedValues::RootLayerExpectedValues(const RootLayerExpectedValues& from)
  : … { … }

inline void RootLayerExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RootLayerExpectedValues::~RootLayerExpectedValues() { … }

inline void RootLayerExpectedValues::SharedDtor() { … }

void RootLayerExpectedValues::SetCachedSize(int size) const { … }

void RootLayerExpectedValues::Clear() { … }

const char* RootLayerExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RootLayerExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RootLayerExpectedValues::ByteSizeLong() const { … }

void RootLayerExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RootLayerExpectedValues::MergeFrom(const RootLayerExpectedValues& from) { … }

void RootLayerExpectedValues::CopyFrom(const RootLayerExpectedValues& from) { … }

bool RootLayerExpectedValues::IsInitialized() const { … }

void RootLayerExpectedValues::InternalSwap(RootLayerExpectedValues* other) { … }

std::string RootLayerExpectedValues::GetTypeName() const { … }


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

class KernelLayerExpectedValues::_Internal { … };

const ::device::enclave::KernelExpectedValues&
KernelLayerExpectedValues::_Internal::kernel(const KernelLayerExpectedValues* msg) { … }
const ::device::enclave::TextExpectedValue&
KernelLayerExpectedValues::_Internal::kernel_cmd_line_text(const KernelLayerExpectedValues* msg) { … }
const ::device::enclave::ExpectedDigests&
KernelLayerExpectedValues::_Internal::init_ram_fs(const KernelLayerExpectedValues* msg) { … }
const ::device::enclave::ExpectedDigests&
KernelLayerExpectedValues::_Internal::memory_map(const KernelLayerExpectedValues* msg) { … }
const ::device::enclave::ExpectedDigests&
KernelLayerExpectedValues::_Internal::acpi(const KernelLayerExpectedValues* msg) { … }
KernelLayerExpectedValues::KernelLayerExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
KernelLayerExpectedValues::KernelLayerExpectedValues(const KernelLayerExpectedValues& from)
  : … { … }

inline void KernelLayerExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

KernelLayerExpectedValues::~KernelLayerExpectedValues() { … }

inline void KernelLayerExpectedValues::SharedDtor() { … }

void KernelLayerExpectedValues::SetCachedSize(int size) const { … }

void KernelLayerExpectedValues::Clear() { … }

const char* KernelLayerExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* KernelLayerExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t KernelLayerExpectedValues::ByteSizeLong() const { … }

void KernelLayerExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void KernelLayerExpectedValues::MergeFrom(const KernelLayerExpectedValues& from) { … }

void KernelLayerExpectedValues::CopyFrom(const KernelLayerExpectedValues& from) { … }

bool KernelLayerExpectedValues::IsInitialized() const { … }

void KernelLayerExpectedValues::InternalSwap(KernelLayerExpectedValues* other) { … }

std::string KernelLayerExpectedValues::GetTypeName() const { … }


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

class SystemLayerExpectedValues::_Internal { … };

const ::device::enclave::ExpectedDigests&
SystemLayerExpectedValues::_Internal::system_image(const SystemLayerExpectedValues* msg) { … }
SystemLayerExpectedValues::SystemLayerExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
SystemLayerExpectedValues::SystemLayerExpectedValues(const SystemLayerExpectedValues& from)
  : … { … }

inline void SystemLayerExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

SystemLayerExpectedValues::~SystemLayerExpectedValues() { … }

inline void SystemLayerExpectedValues::SharedDtor() { … }

void SystemLayerExpectedValues::SetCachedSize(int size) const { … }

void SystemLayerExpectedValues::Clear() { … }

const char* SystemLayerExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* SystemLayerExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t SystemLayerExpectedValues::ByteSizeLong() const { … }

void SystemLayerExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void SystemLayerExpectedValues::MergeFrom(const SystemLayerExpectedValues& from) { … }

void SystemLayerExpectedValues::CopyFrom(const SystemLayerExpectedValues& from) { … }

bool SystemLayerExpectedValues::IsInitialized() const { … }

void SystemLayerExpectedValues::InternalSwap(SystemLayerExpectedValues* other) { … }

std::string SystemLayerExpectedValues::GetTypeName() const { … }


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

class ContainerLayerExpectedValues::_Internal { … };

const ::device::enclave::ExpectedDigests&
ContainerLayerExpectedValues::_Internal::bundle(const ContainerLayerExpectedValues* msg) { … }
const ::device::enclave::ExpectedDigests&
ContainerLayerExpectedValues::_Internal::config(const ContainerLayerExpectedValues* msg) { … }
ContainerLayerExpectedValues::ContainerLayerExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ContainerLayerExpectedValues::ContainerLayerExpectedValues(const ContainerLayerExpectedValues& from)
  : … { … }

inline void ContainerLayerExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ContainerLayerExpectedValues::~ContainerLayerExpectedValues() { … }

inline void ContainerLayerExpectedValues::SharedDtor() { … }

void ContainerLayerExpectedValues::SetCachedSize(int size) const { … }

void ContainerLayerExpectedValues::Clear() { … }

const char* ContainerLayerExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ContainerLayerExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ContainerLayerExpectedValues::ByteSizeLong() const { … }

void ContainerLayerExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ContainerLayerExpectedValues::MergeFrom(const ContainerLayerExpectedValues& from) { … }

void ContainerLayerExpectedValues::CopyFrom(const ContainerLayerExpectedValues& from) { … }

bool ContainerLayerExpectedValues::IsInitialized() const { … }

void ContainerLayerExpectedValues::InternalSwap(ContainerLayerExpectedValues* other) { … }

std::string ContainerLayerExpectedValues::GetTypeName() const { … }


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

class ApplicationLayerExpectedValues::_Internal { … };

const ::device::enclave::ExpectedDigests&
ApplicationLayerExpectedValues::_Internal::binary(const ApplicationLayerExpectedValues* msg) { … }
const ::device::enclave::ExpectedDigests&
ApplicationLayerExpectedValues::_Internal::configuration(const ApplicationLayerExpectedValues* msg) { … }
ApplicationLayerExpectedValues::ApplicationLayerExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ApplicationLayerExpectedValues::ApplicationLayerExpectedValues(const ApplicationLayerExpectedValues& from)
  : … { … }

inline void ApplicationLayerExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ApplicationLayerExpectedValues::~ApplicationLayerExpectedValues() { … }

inline void ApplicationLayerExpectedValues::SharedDtor() { … }

void ApplicationLayerExpectedValues::SetCachedSize(int size) const { … }

void ApplicationLayerExpectedValues::Clear() { … }

const char* ApplicationLayerExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ApplicationLayerExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ApplicationLayerExpectedValues::ByteSizeLong() const { … }

void ApplicationLayerExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ApplicationLayerExpectedValues::MergeFrom(const ApplicationLayerExpectedValues& from) { … }

void ApplicationLayerExpectedValues::CopyFrom(const ApplicationLayerExpectedValues& from) { … }

bool ApplicationLayerExpectedValues::IsInitialized() const { … }

void ApplicationLayerExpectedValues::InternalSwap(ApplicationLayerExpectedValues* other) { … }

std::string ApplicationLayerExpectedValues::GetTypeName() const { … }


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

class OakRestrictedKernelExpectedValues::_Internal { … };

const ::device::enclave::RootLayerExpectedValues&
OakRestrictedKernelExpectedValues::_Internal::root_layer(const OakRestrictedKernelExpectedValues* msg) { … }
const ::device::enclave::KernelLayerExpectedValues&
OakRestrictedKernelExpectedValues::_Internal::kernel_layer(const OakRestrictedKernelExpectedValues* msg) { … }
const ::device::enclave::ApplicationLayerExpectedValues&
OakRestrictedKernelExpectedValues::_Internal::application_layer(const OakRestrictedKernelExpectedValues* msg) { … }
OakRestrictedKernelExpectedValues::OakRestrictedKernelExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
OakRestrictedKernelExpectedValues::OakRestrictedKernelExpectedValues(const OakRestrictedKernelExpectedValues& from)
  : … { … }

inline void OakRestrictedKernelExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

OakRestrictedKernelExpectedValues::~OakRestrictedKernelExpectedValues() { … }

inline void OakRestrictedKernelExpectedValues::SharedDtor() { … }

void OakRestrictedKernelExpectedValues::SetCachedSize(int size) const { … }

void OakRestrictedKernelExpectedValues::Clear() { … }

const char* OakRestrictedKernelExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* OakRestrictedKernelExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t OakRestrictedKernelExpectedValues::ByteSizeLong() const { … }

void OakRestrictedKernelExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void OakRestrictedKernelExpectedValues::MergeFrom(const OakRestrictedKernelExpectedValues& from) { … }

void OakRestrictedKernelExpectedValues::CopyFrom(const OakRestrictedKernelExpectedValues& from) { … }

bool OakRestrictedKernelExpectedValues::IsInitialized() const { … }

void OakRestrictedKernelExpectedValues::InternalSwap(OakRestrictedKernelExpectedValues* other) { … }

std::string OakRestrictedKernelExpectedValues::GetTypeName() const { … }


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

class OakContainersExpectedValues::_Internal { … };

const ::device::enclave::RootLayerExpectedValues&
OakContainersExpectedValues::_Internal::root_layer(const OakContainersExpectedValues* msg) { … }
const ::device::enclave::KernelLayerExpectedValues&
OakContainersExpectedValues::_Internal::kernel_layer(const OakContainersExpectedValues* msg) { … }
const ::device::enclave::SystemLayerExpectedValues&
OakContainersExpectedValues::_Internal::system_layer(const OakContainersExpectedValues* msg) { … }
const ::device::enclave::ContainerLayerExpectedValues&
OakContainersExpectedValues::_Internal::container_layer(const OakContainersExpectedValues* msg) { … }
OakContainersExpectedValues::OakContainersExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
OakContainersExpectedValues::OakContainersExpectedValues(const OakContainersExpectedValues& from)
  : … { … }

inline void OakContainersExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

OakContainersExpectedValues::~OakContainersExpectedValues() { … }

inline void OakContainersExpectedValues::SharedDtor() { … }

void OakContainersExpectedValues::SetCachedSize(int size) const { … }

void OakContainersExpectedValues::Clear() { … }

const char* OakContainersExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* OakContainersExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t OakContainersExpectedValues::ByteSizeLong() const { … }

void OakContainersExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void OakContainersExpectedValues::MergeFrom(const OakContainersExpectedValues& from) { … }

void OakContainersExpectedValues::CopyFrom(const OakContainersExpectedValues& from) { … }

bool OakContainersExpectedValues::IsInitialized() const { … }

void OakContainersExpectedValues::InternalSwap(OakContainersExpectedValues* other) { … }

std::string OakContainersExpectedValues::GetTypeName() const { … }


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

class ExpectedValues::_Internal { … };

const ::device::enclave::OakRestrictedKernelExpectedValues&
ExpectedValues::_Internal::oak_restricted_kernel(const ExpectedValues* msg) { … }
const ::device::enclave::OakContainersExpectedValues&
ExpectedValues::_Internal::oak_containers(const ExpectedValues* msg) { … }
void ExpectedValues::set_allocated_oak_restricted_kernel(::device::enclave::OakRestrictedKernelExpectedValues* oak_restricted_kernel) { … }
void ExpectedValues::set_allocated_oak_containers(::device::enclave::OakContainersExpectedValues* oak_containers) { … }
ExpectedValues::ExpectedValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ExpectedValues::ExpectedValues(const ExpectedValues& from)
  : … { … }

inline void ExpectedValues::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ExpectedValues::~ExpectedValues() { … }

inline void ExpectedValues::SharedDtor() { … }

void ExpectedValues::SetCachedSize(int size) const { … }

void ExpectedValues::clear_type() { … }


void ExpectedValues::Clear() { … }

const char* ExpectedValues::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ExpectedValues::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ExpectedValues::ByteSizeLong() const { … }

void ExpectedValues::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ExpectedValues::MergeFrom(const ExpectedValues& from) { … }

void ExpectedValues::CopyFrom(const ExpectedValues& from) { … }

bool ExpectedValues::IsInitialized() const { … }

void ExpectedValues::InternalSwap(ExpectedValues* other) { … }

std::string ExpectedValues::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace enclave
}  // namespace device
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::device::enclave::VerificationSkipped*
Arena::CreateMaybeMessage< ::device::enclave::VerificationSkipped >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::RawDigests*
Arena::CreateMaybeMessage< ::device::enclave::RawDigests >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::ExpectedDigests*
Arena::CreateMaybeMessage< ::device::enclave::ExpectedDigests >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::KernelExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::KernelExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::AmdSevExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::AmdSevExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::IntelTdxExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::IntelTdxExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::InsecureExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::InsecureExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::ExpectedRegex*
Arena::CreateMaybeMessage< ::device::enclave::ExpectedRegex >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::ExpectedStringLiterals*
Arena::CreateMaybeMessage< ::device::enclave::ExpectedStringLiterals >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::TextExpectedValue*
Arena::CreateMaybeMessage< ::device::enclave::TextExpectedValue >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::RootLayerExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::RootLayerExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::KernelLayerExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::KernelLayerExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::SystemLayerExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::SystemLayerExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::ContainerLayerExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::ContainerLayerExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::ApplicationLayerExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::ApplicationLayerExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::OakRestrictedKernelExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::OakRestrictedKernelExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::OakContainersExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::OakContainersExpectedValues >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::device::enclave::ExpectedValues*
Arena::CreateMaybeMessage< ::device::enclave::ExpectedValues >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>