chromium/out/Default/gen/third_party/anonymous_tokens/src/anonymous_tokens/proto/anonymous_tokens.pb.cc

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

#include "anonymous_tokens/proto/anonymous_tokens.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 anonymous_tokens {
PROTOBUF_CONSTEXPR Timestamp::Timestamp(
    ::_pbi::ConstantInitialized): … { … }
struct TimestampDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TimestampDefaultTypeInternal _Timestamp_default_instance_;
PROTOBUF_CONSTEXPR RSAPrivateKey::RSAPrivateKey(
    ::_pbi::ConstantInitialized): … { … }
struct RSAPrivateKeyDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RSAPrivateKeyDefaultTypeInternal _RSAPrivateKey_default_instance_;
PROTOBUF_CONSTEXPR RSAPublicKey::RSAPublicKey(
    ::_pbi::ConstantInitialized): … { … }
struct RSAPublicKeyDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RSAPublicKeyDefaultTypeInternal _RSAPublicKey_default_instance_;
PROTOBUF_CONSTEXPR RSABlindSignaturePublicKey::RSABlindSignaturePublicKey(
    ::_pbi::ConstantInitialized): … { … }
struct RSABlindSignaturePublicKeyDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RSABlindSignaturePublicKeyDefaultTypeInternal _RSABlindSignaturePublicKey_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensPublicKeysGetRequest::AnonymousTokensPublicKeysGetRequest(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensPublicKeysGetRequestDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensPublicKeysGetRequestDefaultTypeInternal _AnonymousTokensPublicKeysGetRequest_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensPublicKeysGetResponse::AnonymousTokensPublicKeysGetResponse(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensPublicKeysGetResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensPublicKeysGetResponseDefaultTypeInternal _AnonymousTokensPublicKeysGetResponse_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensSignRequest_BlindedToken::AnonymousTokensSignRequest_BlindedToken(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensSignRequest_BlindedTokenDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensSignRequest_BlindedTokenDefaultTypeInternal _AnonymousTokensSignRequest_BlindedToken_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensSignRequest::AnonymousTokensSignRequest(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensSignRequestDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensSignRequestDefaultTypeInternal _AnonymousTokensSignRequest_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensSignResponse_AnonymousToken::AnonymousTokensSignResponse_AnonymousToken(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensSignResponse_AnonymousTokenDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensSignResponse_AnonymousTokenDefaultTypeInternal _AnonymousTokensSignResponse_AnonymousToken_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensSignResponse::AnonymousTokensSignResponse(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensSignResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensSignResponseDefaultTypeInternal _AnonymousTokensSignResponse_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensRedemptionRequest_AnonymousTokenToRedeemDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensRedemptionRequest_AnonymousTokenToRedeemDefaultTypeInternal _AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensRedemptionRequest::AnonymousTokensRedemptionRequest(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensRedemptionRequestDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensRedemptionRequestDefaultTypeInternal _AnonymousTokensRedemptionRequest_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResultDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResultDefaultTypeInternal _AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult_default_instance_;
PROTOBUF_CONSTEXPR AnonymousTokensRedemptionResponse::AnonymousTokensRedemptionResponse(
    ::_pbi::ConstantInitialized): … { … }
struct AnonymousTokensRedemptionResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnonymousTokensRedemptionResponseDefaultTypeInternal _AnonymousTokensRedemptionResponse_default_instance_;
PROTOBUF_CONSTEXPR PlaintextMessageWithPublicMetadata::PlaintextMessageWithPublicMetadata(
    ::_pbi::ConstantInitialized): … { … }
struct PlaintextMessageWithPublicMetadataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PlaintextMessageWithPublicMetadataDefaultTypeInternal _PlaintextMessageWithPublicMetadata_default_instance_;
PROTOBUF_CONSTEXPR RSABlindSignatureToken::RSABlindSignatureToken(
    ::_pbi::ConstantInitialized): … { … }
struct RSABlindSignatureTokenDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RSABlindSignatureTokenDefaultTypeInternal _RSABlindSignatureToken_default_instance_;
PROTOBUF_CONSTEXPR RSABlindSignatureTokenWithInput::RSABlindSignatureTokenWithInput(
    ::_pbi::ConstantInitialized): … { … }
struct RSABlindSignatureTokenWithInputDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RSABlindSignatureTokenWithInputDefaultTypeInternal _RSABlindSignatureTokenWithInput_default_instance_;
PROTOBUF_CONSTEXPR RSABlindSignatureRedemptionResult::RSABlindSignatureRedemptionResult(
    ::_pbi::ConstantInitialized): … { … }
struct RSABlindSignatureRedemptionResultDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RSABlindSignatureRedemptionResultDefaultTypeInternal _RSABlindSignatureRedemptionResult_default_instance_;
}  // namespace anonymous_tokens
namespace anonymous_tokens {
bool AnonymousTokensUseCase_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AnonymousTokensUseCase_strings[11] = …;

static const char AnonymousTokensUseCase_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AnonymousTokensUseCase_entries[] = …;

static const int AnonymousTokensUseCase_entries_by_number[] = …;

const std::string& AnonymousTokensUseCase_Name(
    AnonymousTokensUseCase value) { … }
bool AnonymousTokensUseCase_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AnonymousTokensUseCase* value) { … }
bool HashType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> HashType_strings[4] = …;

static const char HashType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry HashType_entries[] = …;

static const int HashType_entries_by_number[] = …;

const std::string& HashType_Name(
    HashType value) { … }
bool HashType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HashType* value) { … }
bool MaskGenFunction_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MaskGenFunction_strings[4] = …;

static const char MaskGenFunction_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MaskGenFunction_entries[] = …;

static const int MaskGenFunction_entries_by_number[] = …;

const std::string& MaskGenFunction_Name(
    MaskGenFunction value) { … }
bool MaskGenFunction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MaskGenFunction* value) { … }
bool MessageMaskType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MessageMaskType_strings[4] = …;

static const char MessageMaskType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MessageMaskType_entries[] = …;

static const int MessageMaskType_entries_by_number[] = …;

const std::string& MessageMaskType_Name(
    MessageMaskType value) { … }
bool MessageMaskType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MessageMaskType* value) { … }

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

class Timestamp::_Internal { … };

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

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

Timestamp::~Timestamp() { … }

inline void Timestamp::SharedDtor() { … }

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

void Timestamp::Clear() { … }

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

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

size_t Timestamp::ByteSizeLong() const { … }

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

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

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

bool Timestamp::IsInitialized() const { … }

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

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


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

class RSAPrivateKey::_Internal { … };

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

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

RSAPrivateKey::~RSAPrivateKey() { … }

inline void RSAPrivateKey::SharedDtor() { … }

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

void RSAPrivateKey::Clear() { … }

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

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

size_t RSAPrivateKey::ByteSizeLong() const { … }

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

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

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

bool RSAPrivateKey::IsInitialized() const { … }

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

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


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

class RSAPublicKey::_Internal { … };

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

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

RSAPublicKey::~RSAPublicKey() { … }

inline void RSAPublicKey::SharedDtor() { … }

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

void RSAPublicKey::Clear() { … }

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

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

size_t RSAPublicKey::ByteSizeLong() const { … }

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

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

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

bool RSAPublicKey::IsInitialized() const { … }

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

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


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

class RSABlindSignaturePublicKey::_Internal { … };

const ::anonymous_tokens::Timestamp&
RSABlindSignaturePublicKey::_Internal::expiration_time(const RSABlindSignaturePublicKey* msg) { … }
const ::anonymous_tokens::Timestamp&
RSABlindSignaturePublicKey::_Internal::key_validity_start_time(const RSABlindSignaturePublicKey* msg) { … }
RSABlindSignaturePublicKey::RSABlindSignaturePublicKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RSABlindSignaturePublicKey::RSABlindSignaturePublicKey(const RSABlindSignaturePublicKey& from)
  : … { … }

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

RSABlindSignaturePublicKey::~RSABlindSignaturePublicKey() { … }

inline void RSABlindSignaturePublicKey::SharedDtor() { … }

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

void RSABlindSignaturePublicKey::Clear() { … }

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

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

size_t RSABlindSignaturePublicKey::ByteSizeLong() const { … }

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

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

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

bool RSABlindSignaturePublicKey::IsInitialized() const { … }

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

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


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

class AnonymousTokensPublicKeysGetRequest::_Internal { … };

const ::anonymous_tokens::Timestamp&
AnonymousTokensPublicKeysGetRequest::_Internal::key_validity_start_time(const AnonymousTokensPublicKeysGetRequest* msg) { … }
const ::anonymous_tokens::Timestamp&
AnonymousTokensPublicKeysGetRequest::_Internal::key_validity_end_time(const AnonymousTokensPublicKeysGetRequest* msg) { … }
AnonymousTokensPublicKeysGetRequest::AnonymousTokensPublicKeysGetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AnonymousTokensPublicKeysGetRequest::AnonymousTokensPublicKeysGetRequest(const AnonymousTokensPublicKeysGetRequest& from)
  : … { … }

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

AnonymousTokensPublicKeysGetRequest::~AnonymousTokensPublicKeysGetRequest() { … }

inline void AnonymousTokensPublicKeysGetRequest::SharedDtor() { … }

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

void AnonymousTokensPublicKeysGetRequest::Clear() { … }

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

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

size_t AnonymousTokensPublicKeysGetRequest::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensPublicKeysGetRequest::IsInitialized() const { … }

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

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


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

class AnonymousTokensPublicKeysGetResponse::_Internal { … };

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

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

AnonymousTokensPublicKeysGetResponse::~AnonymousTokensPublicKeysGetResponse() { … }

inline void AnonymousTokensPublicKeysGetResponse::SharedDtor() { … }

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

void AnonymousTokensPublicKeysGetResponse::Clear() { … }

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

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

size_t AnonymousTokensPublicKeysGetResponse::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensPublicKeysGetResponse::IsInitialized() const { … }

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

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


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

class AnonymousTokensSignRequest_BlindedToken::_Internal { … };

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

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

AnonymousTokensSignRequest_BlindedToken::~AnonymousTokensSignRequest_BlindedToken() { … }

inline void AnonymousTokensSignRequest_BlindedToken::SharedDtor() { … }

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

void AnonymousTokensSignRequest_BlindedToken::Clear() { … }

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

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

size_t AnonymousTokensSignRequest_BlindedToken::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensSignRequest_BlindedToken::IsInitialized() const { … }

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

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


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

class AnonymousTokensSignRequest::_Internal { … };

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

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

AnonymousTokensSignRequest::~AnonymousTokensSignRequest() { … }

inline void AnonymousTokensSignRequest::SharedDtor() { … }

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

void AnonymousTokensSignRequest::Clear() { … }

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

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

size_t AnonymousTokensSignRequest::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensSignRequest::IsInitialized() const { … }

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

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


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

class AnonymousTokensSignResponse_AnonymousToken::_Internal { … };

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

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

AnonymousTokensSignResponse_AnonymousToken::~AnonymousTokensSignResponse_AnonymousToken() { … }

inline void AnonymousTokensSignResponse_AnonymousToken::SharedDtor() { … }

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

void AnonymousTokensSignResponse_AnonymousToken::Clear() { … }

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

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

size_t AnonymousTokensSignResponse_AnonymousToken::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensSignResponse_AnonymousToken::IsInitialized() const { … }

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

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


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

class AnonymousTokensSignResponse::_Internal { … };

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

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

AnonymousTokensSignResponse::~AnonymousTokensSignResponse() { … }

inline void AnonymousTokensSignResponse::SharedDtor() { … }

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

void AnonymousTokensSignResponse::Clear() { … }

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

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

size_t AnonymousTokensSignResponse::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensSignResponse::IsInitialized() const { … }

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

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


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

class AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::_Internal { … };

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

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

AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::~AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem() { … }

inline void AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::SharedDtor() { … }

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

void AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::Clear() { … }

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

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

size_t AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem::IsInitialized() const { … }

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

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


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

class AnonymousTokensRedemptionRequest::_Internal { … };

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

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

AnonymousTokensRedemptionRequest::~AnonymousTokensRedemptionRequest() { … }

inline void AnonymousTokensRedemptionRequest::SharedDtor() { … }

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

void AnonymousTokensRedemptionRequest::Clear() { … }

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

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

size_t AnonymousTokensRedemptionRequest::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensRedemptionRequest::IsInitialized() const { … }

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

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


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

class AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::_Internal { … };

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

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

AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::~AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult() { … }

inline void AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::SharedDtor() { … }

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

void AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::Clear() { … }

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

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

size_t AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult::IsInitialized() const { … }

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

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


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

class AnonymousTokensRedemptionResponse::_Internal { … };

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

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

AnonymousTokensRedemptionResponse::~AnonymousTokensRedemptionResponse() { … }

inline void AnonymousTokensRedemptionResponse::SharedDtor() { … }

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

void AnonymousTokensRedemptionResponse::Clear() { … }

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

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

size_t AnonymousTokensRedemptionResponse::ByteSizeLong() const { … }

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

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

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

bool AnonymousTokensRedemptionResponse::IsInitialized() const { … }

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

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


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

class PlaintextMessageWithPublicMetadata::_Internal { … };

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

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

PlaintextMessageWithPublicMetadata::~PlaintextMessageWithPublicMetadata() { … }

inline void PlaintextMessageWithPublicMetadata::SharedDtor() { … }

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

void PlaintextMessageWithPublicMetadata::Clear() { … }

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

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

size_t PlaintextMessageWithPublicMetadata::ByteSizeLong() const { … }

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

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

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

bool PlaintextMessageWithPublicMetadata::IsInitialized() const { … }

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

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


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

class RSABlindSignatureToken::_Internal { … };

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

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

RSABlindSignatureToken::~RSABlindSignatureToken() { … }

inline void RSABlindSignatureToken::SharedDtor() { … }

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

void RSABlindSignatureToken::Clear() { … }

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

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

size_t RSABlindSignatureToken::ByteSizeLong() const { … }

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

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

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

bool RSABlindSignatureToken::IsInitialized() const { … }

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

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


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

class RSABlindSignatureTokenWithInput::_Internal { … };

const ::anonymous_tokens::PlaintextMessageWithPublicMetadata&
RSABlindSignatureTokenWithInput::_Internal::input(const RSABlindSignatureTokenWithInput* msg) { … }
const ::anonymous_tokens::RSABlindSignatureToken&
RSABlindSignatureTokenWithInput::_Internal::token(const RSABlindSignatureTokenWithInput* msg) { … }
RSABlindSignatureTokenWithInput::RSABlindSignatureTokenWithInput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RSABlindSignatureTokenWithInput::RSABlindSignatureTokenWithInput(const RSABlindSignatureTokenWithInput& from)
  : … { … }

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

RSABlindSignatureTokenWithInput::~RSABlindSignatureTokenWithInput() { … }

inline void RSABlindSignatureTokenWithInput::SharedDtor() { … }

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

void RSABlindSignatureTokenWithInput::Clear() { … }

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

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

size_t RSABlindSignatureTokenWithInput::ByteSizeLong() const { … }

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

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

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

bool RSABlindSignatureTokenWithInput::IsInitialized() const { … }

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

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


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

class RSABlindSignatureRedemptionResult::_Internal { … };

const ::anonymous_tokens::RSABlindSignatureTokenWithInput&
RSABlindSignatureRedemptionResult::_Internal::token_with_input(const RSABlindSignatureRedemptionResult* msg) { … }
RSABlindSignatureRedemptionResult::RSABlindSignatureRedemptionResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RSABlindSignatureRedemptionResult::RSABlindSignatureRedemptionResult(const RSABlindSignatureRedemptionResult& from)
  : … { … }

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

RSABlindSignatureRedemptionResult::~RSABlindSignatureRedemptionResult() { … }

inline void RSABlindSignatureRedemptionResult::SharedDtor() { … }

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

void RSABlindSignatureRedemptionResult::Clear() { … }

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

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

size_t RSABlindSignatureRedemptionResult::ByteSizeLong() const { … }

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

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

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

bool RSABlindSignatureRedemptionResult::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace anonymous_tokens
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::anonymous_tokens::Timestamp*
Arena::CreateMaybeMessage< ::anonymous_tokens::Timestamp >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::RSAPrivateKey*
Arena::CreateMaybeMessage< ::anonymous_tokens::RSAPrivateKey >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::RSAPublicKey*
Arena::CreateMaybeMessage< ::anonymous_tokens::RSAPublicKey >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::RSABlindSignaturePublicKey*
Arena::CreateMaybeMessage< ::anonymous_tokens::RSABlindSignaturePublicKey >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensPublicKeysGetRequest*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensPublicKeysGetRequest >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensPublicKeysGetResponse*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensPublicKeysGetResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensSignRequest_BlindedToken*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensSignRequest_BlindedToken >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensSignRequest*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensSignRequest >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensSignResponse_AnonymousToken*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensSignResponse_AnonymousToken >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensSignResponse*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensSignResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensRedemptionRequest_AnonymousTokenToRedeem >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensRedemptionRequest*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensRedemptionRequest >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensRedemptionResponse_AnonymousTokenRedemptionResult >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::AnonymousTokensRedemptionResponse*
Arena::CreateMaybeMessage< ::anonymous_tokens::AnonymousTokensRedemptionResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::PlaintextMessageWithPublicMetadata*
Arena::CreateMaybeMessage< ::anonymous_tokens::PlaintextMessageWithPublicMetadata >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::RSABlindSignatureToken*
Arena::CreateMaybeMessage< ::anonymous_tokens::RSABlindSignatureToken >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::RSABlindSignatureTokenWithInput*
Arena::CreateMaybeMessage< ::anonymous_tokens::RSABlindSignatureTokenWithInput >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::anonymous_tokens::RSABlindSignatureRedemptionResult*
Arena::CreateMaybeMessage< ::anonymous_tokens::RSABlindSignatureRedemptionResult >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

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