Codebase Browser
chromium
Go to App

chromium/out/Default/gen/components/sync/protocol/password_sharing_invitation_specifics.pb.cc 

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: components/sync/protocol/password_sharing_invitation_specifics.proto

#include "components/sync/protocol/password_sharing_invitation_specifics.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 sync_pb {
PROTOBUF_CONSTEXPR PasswordSharingInvitationData_PasswordGroupElementData::PasswordSharingInvitationData_PasswordGroupElementData(
    ::_pbi::ConstantInitialized): … { … }
struct PasswordSharingInvitationData_PasswordGroupElementDataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PasswordSharingInvitationData_PasswordGroupElementDataDefaultTypeInternal _PasswordSharingInvitationData_PasswordGroupElementData_default_instance_;
PROTOBUF_CONSTEXPR PasswordSharingInvitationData_PasswordGroupData::PasswordSharingInvitationData_PasswordGroupData(
    ::_pbi::ConstantInitialized): … { … }
struct PasswordSharingInvitationData_PasswordGroupDataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PasswordSharingInvitationData_PasswordGroupDataDefaultTypeInternal _PasswordSharingInvitationData_PasswordGroupData_default_instance_;
PROTOBUF_CONSTEXPR PasswordSharingInvitationData::PasswordSharingInvitationData(
    ::_pbi::ConstantInitialized): … { … }
struct PasswordSharingInvitationDataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PasswordSharingInvitationDataDefaultTypeInternal _PasswordSharingInvitationData_default_instance_;
PROTOBUF_CONSTEXPR UserDisplayInfo::UserDisplayInfo(
    ::_pbi::ConstantInitialized): … { … }
struct UserDisplayInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserDisplayInfoDefaultTypeInternal _UserDisplayInfo_default_instance_;
PROTOBUF_CONSTEXPR UserInfo::UserInfo(
    ::_pbi::ConstantInitialized): … { … }
struct UserInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserInfoDefaultTypeInternal _UserInfo_default_instance_;
PROTOBUF_CONSTEXPR IncomingPasswordSharingInvitationSpecifics::IncomingPasswordSharingInvitationSpecifics(
    ::_pbi::ConstantInitialized): … { … }
struct IncomingPasswordSharingInvitationSpecificsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IncomingPasswordSharingInvitationSpecificsDefaultTypeInternal _IncomingPasswordSharingInvitationSpecifics_default_instance_;
PROTOBUF_CONSTEXPR OutgoingPasswordSharingInvitationSpecifics::OutgoingPasswordSharingInvitationSpecifics(
    ::_pbi::ConstantInitialized): … { … }
struct OutgoingPasswordSharingInvitationSpecificsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OutgoingPasswordSharingInvitationSpecificsDefaultTypeInternal _OutgoingPasswordSharingInvitationSpecifics_default_instance_;
PROTOBUF_CONSTEXPR OutgoingPasswordSharingInvitationCommitError::OutgoingPasswordSharingInvitationCommitError(
    ::_pbi::ConstantInitialized): … { … }
struct OutgoingPasswordSharingInvitationCommitErrorDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OutgoingPasswordSharingInvitationCommitErrorDefaultTypeInternal _OutgoingPasswordSharingInvitationCommitError_default_instance_;
}  // namespace sync_pb
namespace sync_pb {
bool OutgoingPasswordSharingInvitationCommitError_ErrorCode_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OutgoingPasswordSharingInvitationCommitError_ErrorCode_strings[3] = …;

static const char OutgoingPasswordSharingInvitationCommitError_ErrorCode_names[] = …;

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

static const int OutgoingPasswordSharingInvitationCommitError_ErrorCode_entries_by_number[] = …;

const std::string& OutgoingPasswordSharingInvitationCommitError_ErrorCode_Name(
    OutgoingPasswordSharingInvitationCommitError_ErrorCode value) { … }
bool OutgoingPasswordSharingInvitationCommitError_ErrorCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OutgoingPasswordSharingInvitationCommitError_ErrorCode* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr OutgoingPasswordSharingInvitationCommitError_ErrorCode OutgoingPasswordSharingInvitationCommitError::UNKNOWN;
constexpr OutgoingPasswordSharingInvitationCommitError_ErrorCode OutgoingPasswordSharingInvitationCommitError::PUBLIC_KEY_VERSION_MISMATCH;
constexpr OutgoingPasswordSharingInvitationCommitError_ErrorCode OutgoingPasswordSharingInvitationCommitError::NOT_FAMILY_MEMBER;
constexpr OutgoingPasswordSharingInvitationCommitError_ErrorCode OutgoingPasswordSharingInvitationCommitError::ErrorCode_MIN;
constexpr OutgoingPasswordSharingInvitationCommitError_ErrorCode OutgoingPasswordSharingInvitationCommitError::ErrorCode_MAX;
constexpr int OutgoingPasswordSharingInvitationCommitError::ErrorCode_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class PasswordSharingInvitationData_PasswordGroupElementData::_Internal { … };

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

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

PasswordSharingInvitationData_PasswordGroupElementData::~PasswordSharingInvitationData_PasswordGroupElementData() { … }

inline void PasswordSharingInvitationData_PasswordGroupElementData::SharedDtor() { … }

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

void PasswordSharingInvitationData_PasswordGroupElementData::Clear() { … }

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

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

size_t PasswordSharingInvitationData_PasswordGroupElementData::ByteSizeLong() const { … }

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

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

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

bool PasswordSharingInvitationData_PasswordGroupElementData::IsInitialized() const { … }

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

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


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

class PasswordSharingInvitationData_PasswordGroupData::_Internal { … };

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

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

PasswordSharingInvitationData_PasswordGroupData::~PasswordSharingInvitationData_PasswordGroupData() { … }

inline void PasswordSharingInvitationData_PasswordGroupData::SharedDtor() { … }

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

void PasswordSharingInvitationData_PasswordGroupData::Clear() { … }

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

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

size_t PasswordSharingInvitationData_PasswordGroupData::ByteSizeLong() const { … }

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

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

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

bool PasswordSharingInvitationData_PasswordGroupData::IsInitialized() const { … }

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

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


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

class PasswordSharingInvitationData::_Internal { … };

const ::sync_pb::PasswordSharingInvitationData_PasswordGroupData&
PasswordSharingInvitationData::_Internal::password_group_data(const PasswordSharingInvitationData* msg) { … }
PasswordSharingInvitationData::PasswordSharingInvitationData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
PasswordSharingInvitationData::PasswordSharingInvitationData(const PasswordSharingInvitationData& from)
  : … { … }

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

PasswordSharingInvitationData::~PasswordSharingInvitationData() { … }

inline void PasswordSharingInvitationData::SharedDtor() { … }

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

void PasswordSharingInvitationData::Clear() { … }

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

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

size_t PasswordSharingInvitationData::ByteSizeLong() const { … }

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

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

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

bool PasswordSharingInvitationData::IsInitialized() const { … }

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

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


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

class UserDisplayInfo::_Internal { … };

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

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

UserDisplayInfo::~UserDisplayInfo() { … }

inline void UserDisplayInfo::SharedDtor() { … }

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

void UserDisplayInfo::Clear() { … }

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

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

size_t UserDisplayInfo::ByteSizeLong() const { … }

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

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

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

bool UserDisplayInfo::IsInitialized() const { … }

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

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


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

class UserInfo::_Internal { … };

const ::sync_pb::UserDisplayInfo&
UserInfo::_Internal::user_display_info(const UserInfo* msg) { … }
const ::sync_pb::CrossUserSharingPublicKey&
UserInfo::_Internal::cross_user_sharing_public_key(const UserInfo* msg) { … }
void UserInfo::clear_cross_user_sharing_public_key() { … }
UserInfo::UserInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
UserInfo::UserInfo(const UserInfo& from)
  : … { … }

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

UserInfo::~UserInfo() { … }

inline void UserInfo::SharedDtor() { … }

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

void UserInfo::Clear() { … }

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

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

size_t UserInfo::ByteSizeLong() const { … }

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

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

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

bool UserInfo::IsInitialized() const { … }

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

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


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

class IncomingPasswordSharingInvitationSpecifics::_Internal { … };

const ::sync_pb::UserInfo&
IncomingPasswordSharingInvitationSpecifics::_Internal::sender_info(const IncomingPasswordSharingInvitationSpecifics* msg) { … }
const ::sync_pb::PasswordSharingInvitationData&
IncomingPasswordSharingInvitationSpecifics::_Internal::client_only_unencrypted_data(const IncomingPasswordSharingInvitationSpecifics* msg) { … }
IncomingPasswordSharingInvitationSpecifics::IncomingPasswordSharingInvitationSpecifics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
IncomingPasswordSharingInvitationSpecifics::IncomingPasswordSharingInvitationSpecifics(const IncomingPasswordSharingInvitationSpecifics& from)
  : … { … }

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

IncomingPasswordSharingInvitationSpecifics::~IncomingPasswordSharingInvitationSpecifics() { … }

inline void IncomingPasswordSharingInvitationSpecifics::SharedDtor() { … }

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

void IncomingPasswordSharingInvitationSpecifics::Clear() { … }

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

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

size_t IncomingPasswordSharingInvitationSpecifics::ByteSizeLong() const { … }

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

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

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

bool IncomingPasswordSharingInvitationSpecifics::IsInitialized() const { … }

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

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


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

class OutgoingPasswordSharingInvitationSpecifics::_Internal { … };

const ::sync_pb::PasswordSharingInvitationData&
OutgoingPasswordSharingInvitationSpecifics::_Internal::client_only_unencrypted_data(const OutgoingPasswordSharingInvitationSpecifics* msg) { … }
OutgoingPasswordSharingInvitationSpecifics::OutgoingPasswordSharingInvitationSpecifics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
OutgoingPasswordSharingInvitationSpecifics::OutgoingPasswordSharingInvitationSpecifics(const OutgoingPasswordSharingInvitationSpecifics& from)
  : … { … }

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

OutgoingPasswordSharingInvitationSpecifics::~OutgoingPasswordSharingInvitationSpecifics() { … }

inline void OutgoingPasswordSharingInvitationSpecifics::SharedDtor() { … }

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

void OutgoingPasswordSharingInvitationSpecifics::Clear() { … }

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

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

size_t OutgoingPasswordSharingInvitationSpecifics::ByteSizeLong() const { … }

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

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

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

bool OutgoingPasswordSharingInvitationSpecifics::IsInitialized() const { … }

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

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


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

class OutgoingPasswordSharingInvitationCommitError::_Internal { … };

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

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

OutgoingPasswordSharingInvitationCommitError::~OutgoingPasswordSharingInvitationCommitError() { … }

inline void OutgoingPasswordSharingInvitationCommitError::SharedDtor() { … }

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

void OutgoingPasswordSharingInvitationCommitError::Clear() { … }

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

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

size_t OutgoingPasswordSharingInvitationCommitError::ByteSizeLong() const { … }

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

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

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

bool OutgoingPasswordSharingInvitationCommitError::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace sync_pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sync_pb::PasswordSharingInvitationData_PasswordGroupElementData*
Arena::CreateMaybeMessage< ::sync_pb::PasswordSharingInvitationData_PasswordGroupElementData >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::PasswordSharingInvitationData_PasswordGroupData*
Arena::CreateMaybeMessage< ::sync_pb::PasswordSharingInvitationData_PasswordGroupData >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::PasswordSharingInvitationData*
Arena::CreateMaybeMessage< ::sync_pb::PasswordSharingInvitationData >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserDisplayInfo*
Arena::CreateMaybeMessage< ::sync_pb::UserDisplayInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserInfo*
Arena::CreateMaybeMessage< ::sync_pb::UserInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::IncomingPasswordSharingInvitationSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::IncomingPasswordSharingInvitationSpecifics >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::OutgoingPasswordSharingInvitationSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::OutgoingPasswordSharingInvitationSpecifics >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::OutgoingPasswordSharingInvitationCommitError*
Arena::CreateMaybeMessage< ::sync_pb::OutgoingPasswordSharingInvitationCommitError >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

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