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

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

#include "components/sync/protocol/autofill_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 AutofillProfileSpecifics::AutofillProfileSpecifics(
    ::_pbi::ConstantInitialized):{}
struct AutofillProfileSpecificsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AutofillProfileSpecificsDefaultTypeInternal _AutofillProfileSpecifics_default_instance_;
PROTOBUF_CONSTEXPR AutofillSpecifics::AutofillSpecifics(
    ::_pbi::ConstantInitialized):{}
struct AutofillSpecificsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AutofillSpecificsDefaultTypeInternal _AutofillSpecifics_default_instance_;
PROTOBUF_CONSTEXPR CloudTokenData::CloudTokenData(
    ::_pbi::ConstantInitialized):{}
struct CloudTokenDataDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CloudTokenDataDefaultTypeInternal _CloudTokenData_default_instance_;
PROTOBUF_CONSTEXPR CardBenefit_FlatRateBenefit::CardBenefit_FlatRateBenefit(
    ::_pbi::ConstantInitialized):{}
struct CardBenefit_FlatRateBenefitDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CardBenefit_FlatRateBenefitDefaultTypeInternal _CardBenefit_FlatRateBenefit_default_instance_;
PROTOBUF_CONSTEXPR CardBenefit_CategoryBenefit::CardBenefit_CategoryBenefit(
    ::_pbi::ConstantInitialized):{}
struct CardBenefit_CategoryBenefitDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CardBenefit_CategoryBenefitDefaultTypeInternal _CardBenefit_CategoryBenefit_default_instance_;
PROTOBUF_CONSTEXPR CardBenefit_MerchantBenefit::CardBenefit_MerchantBenefit(
    ::_pbi::ConstantInitialized):{}
struct CardBenefit_MerchantBenefitDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CardBenefit_MerchantBenefitDefaultTypeInternal _CardBenefit_MerchantBenefit_default_instance_;
PROTOBUF_CONSTEXPR CardBenefit::CardBenefit(
    ::_pbi::ConstantInitialized):{}
struct CardBenefitDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CardBenefitDefaultTypeInternal _CardBenefit_default_instance_;
PROTOBUF_CONSTEXPR CardIssuer::CardIssuer(
    ::_pbi::ConstantInitialized):{}
struct CardIssuerDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CardIssuerDefaultTypeInternal _CardIssuer_default_instance_;
PROTOBUF_CONSTEXPR WalletMaskedCreditCard::WalletMaskedCreditCard(
    ::_pbi::ConstantInitialized):{}
struct WalletMaskedCreditCardDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WalletMaskedCreditCardDefaultTypeInternal _WalletMaskedCreditCard_default_instance_;
PROTOBUF_CONSTEXPR WalletPostalAddress::WalletPostalAddress(
    ::_pbi::ConstantInitialized):{}
struct WalletPostalAddressDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WalletPostalAddressDefaultTypeInternal _WalletPostalAddress_default_instance_;
PROTOBUF_CONSTEXPR PaymentsCustomerData::PaymentsCustomerData(
    ::_pbi::ConstantInitialized):{}
struct PaymentsCustomerDataDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentsCustomerDataDefaultTypeInternal _PaymentsCustomerData_default_instance_;
PROTOBUF_CONSTEXPR WalletCreditCardCloudTokenData::WalletCreditCardCloudTokenData(
    ::_pbi::ConstantInitialized):{}
struct WalletCreditCardCloudTokenDataDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WalletCreditCardCloudTokenDataDefaultTypeInternal _WalletCreditCardCloudTokenData_default_instance_;
PROTOBUF_CONSTEXPR PaymentInstrument::PaymentInstrument(
    ::_pbi::ConstantInitialized):{}
struct PaymentInstrumentDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentInstrumentDefaultTypeInternal _PaymentInstrument_default_instance_;
PROTOBUF_CONSTEXPR WalletMaskedIban::WalletMaskedIban(
    ::_pbi::ConstantInitialized):{}
struct WalletMaskedIbanDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WalletMaskedIbanDefaultTypeInternal _WalletMaskedIban_default_instance_;
PROTOBUF_CONSTEXPR BankAccountDetails::BankAccountDetails(
    ::_pbi::ConstantInitialized):{}
struct BankAccountDetailsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BankAccountDetailsDefaultTypeInternal _BankAccountDetails_default_instance_;
PROTOBUF_CONSTEXPR EwalletDetails::EwalletDetails(
    ::_pbi::ConstantInitialized):{}
struct EwalletDetailsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EwalletDetailsDefaultTypeInternal _EwalletDetails_default_instance_;
PROTOBUF_CONSTEXPR DeviceDetails::DeviceDetails(
    ::_pbi::ConstantInitialized):{}
struct DeviceDetailsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceDetailsDefaultTypeInternal _DeviceDetails_default_instance_;
PROTOBUF_CONSTEXPR AutofillWalletSpecifics::AutofillWalletSpecifics(
    ::_pbi::ConstantInitialized):{}
struct AutofillWalletSpecificsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AutofillWalletSpecificsDefaultTypeInternal _AutofillWalletSpecifics_default_instance_;
PROTOBUF_CONSTEXPR WalletMetadataSpecifics::WalletMetadataSpecifics(
    ::_pbi::ConstantInitialized):{}
struct WalletMetadataSpecificsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WalletMetadataSpecificsDefaultTypeInternal _WalletMetadataSpecifics_default_instance_;
}  // namespace sync_pb
namespace sync_pb {
bool AutofillProfileSpecifics_VerificationStatus_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AutofillProfileSpecifics_VerificationStatus_strings[6] =;

static const char AutofillProfileSpecifics_VerificationStatus_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AutofillProfileSpecifics_VerificationStatus_entries[] =;

static const int AutofillProfileSpecifics_VerificationStatus_entries_by_number[] =;

const std::string& AutofillProfileSpecifics_VerificationStatus_Name(
    AutofillProfileSpecifics_VerificationStatus value) {}
bool AutofillProfileSpecifics_VerificationStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutofillProfileSpecifics_VerificationStatus* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::VERIFICATION_STATUS_UNSPECIFIED;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::PARSED;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::FORMATTED;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::OBSERVED;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::USER_VERIFIED;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::SERVER_PARSED;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::VerificationStatus_MIN;
constexpr AutofillProfileSpecifics_VerificationStatus AutofillProfileSpecifics::VerificationStatus_MAX;
constexpr int AutofillProfileSpecifics::VerificationStatus_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CardBenefit_CategoryBenefitType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CardBenefit_CategoryBenefitType_strings[7] =;

static const char CardBenefit_CategoryBenefitType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CardBenefit_CategoryBenefitType_entries[] =;

static const int CardBenefit_CategoryBenefitType_entries_by_number[] =;

const std::string& CardBenefit_CategoryBenefitType_Name(
    CardBenefit_CategoryBenefitType value) {}
bool CardBenefit_CategoryBenefitType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CardBenefit_CategoryBenefitType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CardBenefit_CategoryBenefitType CardBenefit::CATEGORY_BENEFIT_TYPE_UNKNOWN;
constexpr CardBenefit_CategoryBenefitType CardBenefit::SUBSCRIPTION;
constexpr CardBenefit_CategoryBenefitType CardBenefit::FLIGHTS;
constexpr CardBenefit_CategoryBenefitType CardBenefit::DINING;
constexpr CardBenefit_CategoryBenefitType CardBenefit::ENTERTAINMENT;
constexpr CardBenefit_CategoryBenefitType CardBenefit::STREAMING;
constexpr CardBenefit_CategoryBenefitType CardBenefit::GROCERY_STORES;
constexpr CardBenefit_CategoryBenefitType CardBenefit::CategoryBenefitType_MIN;
constexpr CardBenefit_CategoryBenefitType CardBenefit::CategoryBenefitType_MAX;
constexpr int CardBenefit::CategoryBenefitType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CardIssuer_Issuer_IsValid(int value) {}

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

static const char CardIssuer_Issuer_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CardIssuer_Issuer_entries[] =;

static const int CardIssuer_Issuer_entries_by_number[] =;

const std::string& CardIssuer_Issuer_Name(
    CardIssuer_Issuer value) {}
bool CardIssuer_Issuer_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CardIssuer_Issuer* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CardIssuer_Issuer CardIssuer::ISSUER_UNKNOWN;
constexpr CardIssuer_Issuer CardIssuer::GOOGLE;
constexpr CardIssuer_Issuer CardIssuer::EXTERNAL_ISSUER;
constexpr CardIssuer_Issuer CardIssuer::Issuer_MIN;
constexpr CardIssuer_Issuer CardIssuer::Issuer_MAX;
constexpr int CardIssuer::Issuer_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool WalletMaskedCreditCard_WalletCardStatus_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> WalletMaskedCreditCard_WalletCardStatus_strings[2] =;

static const char WalletMaskedCreditCard_WalletCardStatus_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WalletMaskedCreditCard_WalletCardStatus_entries[] =;

static const int WalletMaskedCreditCard_WalletCardStatus_entries_by_number[] =;

const std::string& WalletMaskedCreditCard_WalletCardStatus_Name(
    WalletMaskedCreditCard_WalletCardStatus value) {}
bool WalletMaskedCreditCard_WalletCardStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WalletMaskedCreditCard_WalletCardStatus* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr WalletMaskedCreditCard_WalletCardStatus WalletMaskedCreditCard::VALID;
constexpr WalletMaskedCreditCard_WalletCardStatus WalletMaskedCreditCard::EXPIRED;
constexpr WalletMaskedCreditCard_WalletCardStatus WalletMaskedCreditCard::WalletCardStatus_MIN;
constexpr WalletMaskedCreditCard_WalletCardStatus WalletMaskedCreditCard::WalletCardStatus_MAX;
constexpr int WalletMaskedCreditCard::WalletCardStatus_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool WalletMaskedCreditCard_WalletCardType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> WalletMaskedCreditCard_WalletCardType_strings[12] =;

static const char WalletMaskedCreditCard_WalletCardType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WalletMaskedCreditCard_WalletCardType_entries[] =;

static const int WalletMaskedCreditCard_WalletCardType_entries_by_number[] =;

const std::string& WalletMaskedCreditCard_WalletCardType_Name(
    WalletMaskedCreditCard_WalletCardType value) {}
bool WalletMaskedCreditCard_WalletCardType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WalletMaskedCreditCard_WalletCardType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::UNKNOWN;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::AMEX;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::DISCOVER;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::JCB;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::MAESTRO;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::MASTER_CARD;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::SOLO;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::SWITCH;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::VISA;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::UNIONPAY;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::ELO;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::VERVE;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::WalletCardType_MIN;
constexpr WalletMaskedCreditCard_WalletCardType WalletMaskedCreditCard::WalletCardType_MAX;
constexpr int WalletMaskedCreditCard::WalletCardType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool WalletMaskedCreditCard_VirtualCardEnrollmentState_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> WalletMaskedCreditCard_VirtualCardEnrollmentState_strings[5] =;

static const char WalletMaskedCreditCard_VirtualCardEnrollmentState_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WalletMaskedCreditCard_VirtualCardEnrollmentState_entries[] =;

static const int WalletMaskedCreditCard_VirtualCardEnrollmentState_entries_by_number[] =;

const std::string& WalletMaskedCreditCard_VirtualCardEnrollmentState_Name(
    WalletMaskedCreditCard_VirtualCardEnrollmentState value) {}
bool WalletMaskedCreditCard_VirtualCardEnrollmentState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WalletMaskedCreditCard_VirtualCardEnrollmentState* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::UNSPECIFIED;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::UNENROLLED;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::ENROLLED;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::UNENROLLED_AND_NOT_ELIGIBLE;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::UNENROLLED_AND_ELIGIBLE;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::VirtualCardEnrollmentState_MIN;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentState WalletMaskedCreditCard::VirtualCardEnrollmentState_MAX;
constexpr int WalletMaskedCreditCard::VirtualCardEnrollmentState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool WalletMaskedCreditCard_VirtualCardEnrollmentType_IsValid(int value) {}

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

static const char WalletMaskedCreditCard_VirtualCardEnrollmentType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WalletMaskedCreditCard_VirtualCardEnrollmentType_entries[] =;

static const int WalletMaskedCreditCard_VirtualCardEnrollmentType_entries_by_number[] =;

const std::string& WalletMaskedCreditCard_VirtualCardEnrollmentType_Name(
    WalletMaskedCreditCard_VirtualCardEnrollmentType value) {}
bool WalletMaskedCreditCard_VirtualCardEnrollmentType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WalletMaskedCreditCard_VirtualCardEnrollmentType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentType WalletMaskedCreditCard::TYPE_UNSPECIFIED;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentType WalletMaskedCreditCard::ISSUER;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentType WalletMaskedCreditCard::NETWORK;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentType WalletMaskedCreditCard::VirtualCardEnrollmentType_MIN;
constexpr WalletMaskedCreditCard_VirtualCardEnrollmentType WalletMaskedCreditCard::VirtualCardEnrollmentType_MAX;
constexpr int WalletMaskedCreditCard::VirtualCardEnrollmentType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool PaymentInstrument_SupportedRail_IsValid(int value) {}

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

static const char PaymentInstrument_SupportedRail_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PaymentInstrument_SupportedRail_entries[] =;

static const int PaymentInstrument_SupportedRail_entries_by_number[] =;

const std::string& PaymentInstrument_SupportedRail_Name(
    PaymentInstrument_SupportedRail value) {}
bool PaymentInstrument_SupportedRail_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInstrument_SupportedRail* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr PaymentInstrument_SupportedRail PaymentInstrument::SUPPORTED_RAIL_UNKNOWN;
constexpr PaymentInstrument_SupportedRail PaymentInstrument::PIX;
constexpr PaymentInstrument_SupportedRail PaymentInstrument::IBAN;
constexpr PaymentInstrument_SupportedRail PaymentInstrument::PAYMENT_HYPERLINK;
constexpr PaymentInstrument_SupportedRail PaymentInstrument::SupportedRail_MIN;
constexpr PaymentInstrument_SupportedRail PaymentInstrument::SupportedRail_MAX;
constexpr int PaymentInstrument::SupportedRail_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool BankAccountDetails_AccountType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BankAccountDetails_AccountType_strings[6] =;

static const char BankAccountDetails_AccountType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BankAccountDetails_AccountType_entries[] =;

static const int BankAccountDetails_AccountType_entries_by_number[] =;

const std::string& BankAccountDetails_AccountType_Name(
    BankAccountDetails_AccountType value) {}
bool BankAccountDetails_AccountType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BankAccountDetails_AccountType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr BankAccountDetails_AccountType BankAccountDetails::ACCOUNT_TYPE_UNSPECIFIED;
constexpr BankAccountDetails_AccountType BankAccountDetails::CHECKING;
constexpr BankAccountDetails_AccountType BankAccountDetails::SAVINGS;
constexpr BankAccountDetails_AccountType BankAccountDetails::CURRENT;
constexpr BankAccountDetails_AccountType BankAccountDetails::SALARY;
constexpr BankAccountDetails_AccountType BankAccountDetails::TRANSACTING_ACCOUNT;
constexpr BankAccountDetails_AccountType BankAccountDetails::AccountType_MIN;
constexpr BankAccountDetails_AccountType BankAccountDetails::AccountType_MAX;
constexpr int BankAccountDetails::AccountType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool AutofillWalletSpecifics_WalletInfoType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AutofillWalletSpecifics_WalletInfoType_strings[7] =;

static const char AutofillWalletSpecifics_WalletInfoType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AutofillWalletSpecifics_WalletInfoType_entries[] =;

static const int AutofillWalletSpecifics_WalletInfoType_entries_by_number[] =;

const std::string& AutofillWalletSpecifics_WalletInfoType_Name(
    AutofillWalletSpecifics_WalletInfoType value) {}
bool AutofillWalletSpecifics_WalletInfoType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutofillWalletSpecifics_WalletInfoType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::UNKNOWN;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::MASKED_CREDIT_CARD;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::POSTAL_ADDRESS;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::CUSTOMER_DATA;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::CREDIT_CARD_CLOUD_TOKEN_DATA;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::PAYMENT_INSTRUMENT;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::MASKED_IBAN;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::WalletInfoType_MIN;
constexpr AutofillWalletSpecifics_WalletInfoType AutofillWalletSpecifics::WalletInfoType_MAX;
constexpr int AutofillWalletSpecifics::WalletInfoType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool WalletMetadataSpecifics_Type_IsValid(int value) {}

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

static const char WalletMetadataSpecifics_Type_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WalletMetadataSpecifics_Type_entries[] =;

static const int WalletMetadataSpecifics_Type_entries_by_number[] =;

const std::string& WalletMetadataSpecifics_Type_Name(
    WalletMetadataSpecifics_Type value) {}
bool WalletMetadataSpecifics_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WalletMetadataSpecifics_Type* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr WalletMetadataSpecifics_Type WalletMetadataSpecifics::UNKNOWN;
constexpr WalletMetadataSpecifics_Type WalletMetadataSpecifics::CARD;
constexpr WalletMetadataSpecifics_Type WalletMetadataSpecifics::ADDRESS;
constexpr WalletMetadataSpecifics_Type WalletMetadataSpecifics::IBAN;
constexpr WalletMetadataSpecifics_Type WalletMetadataSpecifics::Type_MIN;
constexpr WalletMetadataSpecifics_Type WalletMetadataSpecifics::Type_MAX;
constexpr int WalletMetadataSpecifics::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class AutofillProfileSpecifics::_Internal {};

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

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

AutofillProfileSpecifics::~AutofillProfileSpecifics() {}

inline void AutofillProfileSpecifics::SharedDtor() {}

void AutofillProfileSpecifics::SetCachedSize(int size) const {}

void AutofillProfileSpecifics::Clear() {}

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

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

size_t AutofillProfileSpecifics::ByteSizeLong() const {}

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

void AutofillProfileSpecifics::MergeFrom(const AutofillProfileSpecifics& from) {}

void AutofillProfileSpecifics::CopyFrom(const AutofillProfileSpecifics& from) {}

bool AutofillProfileSpecifics::IsInitialized() const {}

void AutofillProfileSpecifics::InternalSwap(AutofillProfileSpecifics* other) {}

std::string AutofillProfileSpecifics::GetTypeName() const {}


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

class AutofillSpecifics::_Internal {};

const ::sync_pb::AutofillProfileSpecifics&
AutofillSpecifics::_Internal::profile(const AutofillSpecifics* msg) {}
AutofillSpecifics::AutofillSpecifics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AutofillSpecifics::AutofillSpecifics(const AutofillSpecifics& from)
  :{}

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

AutofillSpecifics::~AutofillSpecifics() {}

inline void AutofillSpecifics::SharedDtor() {}

void AutofillSpecifics::SetCachedSize(int size) const {}

void AutofillSpecifics::Clear() {}

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

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

size_t AutofillSpecifics::ByteSizeLong() const {}

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

void AutofillSpecifics::MergeFrom(const AutofillSpecifics& from) {}

void AutofillSpecifics::CopyFrom(const AutofillSpecifics& from) {}

bool AutofillSpecifics::IsInitialized() const {}

void AutofillSpecifics::InternalSwap(AutofillSpecifics* other) {}

std::string AutofillSpecifics::GetTypeName() const {}


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

class CloudTokenData::_Internal {};

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

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

CloudTokenData::~CloudTokenData() {}

inline void CloudTokenData::SharedDtor() {}

void CloudTokenData::SetCachedSize(int size) const {}

void CloudTokenData::Clear() {}

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

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

size_t CloudTokenData::ByteSizeLong() const {}

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

void CloudTokenData::MergeFrom(const CloudTokenData& from) {}

void CloudTokenData::CopyFrom(const CloudTokenData& from) {}

bool CloudTokenData::IsInitialized() const {}

void CloudTokenData::InternalSwap(CloudTokenData* other) {}

std::string CloudTokenData::GetTypeName() const {}


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

class CardBenefit_FlatRateBenefit::_Internal {};

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

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

CardBenefit_FlatRateBenefit::~CardBenefit_FlatRateBenefit() {}

inline void CardBenefit_FlatRateBenefit::SharedDtor() {}

void CardBenefit_FlatRateBenefit::SetCachedSize(int size) const {}

void CardBenefit_FlatRateBenefit::Clear() {}

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

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

size_t CardBenefit_FlatRateBenefit::ByteSizeLong() const {}

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

void CardBenefit_FlatRateBenefit::MergeFrom(const CardBenefit_FlatRateBenefit& from) {}

void CardBenefit_FlatRateBenefit::CopyFrom(const CardBenefit_FlatRateBenefit& from) {}

bool CardBenefit_FlatRateBenefit::IsInitialized() const {}

void CardBenefit_FlatRateBenefit::InternalSwap(CardBenefit_FlatRateBenefit* other) {}

std::string CardBenefit_FlatRateBenefit::GetTypeName() const {}


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

class CardBenefit_CategoryBenefit::_Internal {};

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

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

CardBenefit_CategoryBenefit::~CardBenefit_CategoryBenefit() {}

inline void CardBenefit_CategoryBenefit::SharedDtor() {}

void CardBenefit_CategoryBenefit::SetCachedSize(int size) const {}

void CardBenefit_CategoryBenefit::Clear() {}

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

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

size_t CardBenefit_CategoryBenefit::ByteSizeLong() const {}

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

void CardBenefit_CategoryBenefit::MergeFrom(const CardBenefit_CategoryBenefit& from) {}

void CardBenefit_CategoryBenefit::CopyFrom(const CardBenefit_CategoryBenefit& from) {}

bool CardBenefit_CategoryBenefit::IsInitialized() const {}

void CardBenefit_CategoryBenefit::InternalSwap(CardBenefit_CategoryBenefit* other) {}

std::string CardBenefit_CategoryBenefit::GetTypeName() const {}


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

class CardBenefit_MerchantBenefit::_Internal {};

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

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

CardBenefit_MerchantBenefit::~CardBenefit_MerchantBenefit() {}

inline void CardBenefit_MerchantBenefit::SharedDtor() {}

void CardBenefit_MerchantBenefit::SetCachedSize(int size) const {}

void CardBenefit_MerchantBenefit::Clear() {}

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

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

size_t CardBenefit_MerchantBenefit::ByteSizeLong() const {}

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

void CardBenefit_MerchantBenefit::MergeFrom(const CardBenefit_MerchantBenefit& from) {}

void CardBenefit_MerchantBenefit::CopyFrom(const CardBenefit_MerchantBenefit& from) {}

bool CardBenefit_MerchantBenefit::IsInitialized() const {}

void CardBenefit_MerchantBenefit::InternalSwap(CardBenefit_MerchantBenefit* other) {}

std::string CardBenefit_MerchantBenefit::GetTypeName() const {}


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

class CardBenefit::_Internal {};

const ::sync_pb::CardBenefit_FlatRateBenefit&
CardBenefit::_Internal::flat_rate_benefit(const CardBenefit* msg) {}
const ::sync_pb::CardBenefit_CategoryBenefit&
CardBenefit::_Internal::category_benefit(const CardBenefit* msg) {}
const ::sync_pb::CardBenefit_MerchantBenefit&
CardBenefit::_Internal::merchant_benefit(const CardBenefit* msg) {}
void CardBenefit::set_allocated_flat_rate_benefit(::sync_pb::CardBenefit_FlatRateBenefit* flat_rate_benefit) {}
void CardBenefit::set_allocated_category_benefit(::sync_pb::CardBenefit_CategoryBenefit* category_benefit) {}
void CardBenefit::set_allocated_merchant_benefit(::sync_pb::CardBenefit_MerchantBenefit* merchant_benefit) {}
CardBenefit::CardBenefit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
CardBenefit::CardBenefit(const CardBenefit& from)
  :{}

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

CardBenefit::~CardBenefit() {}

inline void CardBenefit::SharedDtor() {}

void CardBenefit::SetCachedSize(int size) const {}

void CardBenefit::clear_DomainSpecificBenefit() {}


void CardBenefit::Clear() {}

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

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

size_t CardBenefit::ByteSizeLong() const {}

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

void CardBenefit::MergeFrom(const CardBenefit& from) {}

void CardBenefit::CopyFrom(const CardBenefit& from) {}

bool CardBenefit::IsInitialized() const {}

void CardBenefit::InternalSwap(CardBenefit* other) {}

std::string CardBenefit::GetTypeName() const {}


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

class CardIssuer::_Internal {};

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

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

CardIssuer::~CardIssuer() {}

inline void CardIssuer::SharedDtor() {}

void CardIssuer::SetCachedSize(int size) const {}

void CardIssuer::Clear() {}

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

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

size_t CardIssuer::ByteSizeLong() const {}

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

void CardIssuer::MergeFrom(const CardIssuer& from) {}

void CardIssuer::CopyFrom(const CardIssuer& from) {}

bool CardIssuer::IsInitialized() const {}

void CardIssuer::InternalSwap(CardIssuer* other) {}

std::string CardIssuer::GetTypeName() const {}


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

class WalletMaskedCreditCard::_Internal {};

const ::sync_pb::CloudTokenData&
WalletMaskedCreditCard::_Internal::cloud_token_data(const WalletMaskedCreditCard* msg) {}
const ::sync_pb::CardIssuer&
WalletMaskedCreditCard::_Internal::card_issuer(const WalletMaskedCreditCard* msg) {}
WalletMaskedCreditCard::WalletMaskedCreditCard(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
WalletMaskedCreditCard::WalletMaskedCreditCard(const WalletMaskedCreditCard& from)
  :{}

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

WalletMaskedCreditCard::~WalletMaskedCreditCard() {}

inline void WalletMaskedCreditCard::SharedDtor() {}

void WalletMaskedCreditCard::SetCachedSize(int size) const {}

void WalletMaskedCreditCard::Clear() {}

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

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

size_t WalletMaskedCreditCard::ByteSizeLong() const {}

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

void WalletMaskedCreditCard::MergeFrom(const WalletMaskedCreditCard& from) {}

void WalletMaskedCreditCard::CopyFrom(const WalletMaskedCreditCard& from) {}

bool WalletMaskedCreditCard::IsInitialized() const {}

void WalletMaskedCreditCard::InternalSwap(WalletMaskedCreditCard* other) {}

std::string WalletMaskedCreditCard::GetTypeName() const {}


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

class WalletPostalAddress::_Internal {};

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

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

WalletPostalAddress::~WalletPostalAddress() {}

inline void WalletPostalAddress::SharedDtor() {}

void WalletPostalAddress::SetCachedSize(int size) const {}

void WalletPostalAddress::Clear() {}

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

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

size_t WalletPostalAddress::ByteSizeLong() const {}

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

void WalletPostalAddress::MergeFrom(const WalletPostalAddress& from) {}

void WalletPostalAddress::CopyFrom(const WalletPostalAddress& from) {}

bool WalletPostalAddress::IsInitialized() const {}

void WalletPostalAddress::InternalSwap(WalletPostalAddress* other) {}

std::string WalletPostalAddress::GetTypeName() const {}


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

class PaymentsCustomerData::_Internal {};

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

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

PaymentsCustomerData::~PaymentsCustomerData() {}

inline void PaymentsCustomerData::SharedDtor() {}

void PaymentsCustomerData::SetCachedSize(int size) const {}

void PaymentsCustomerData::Clear() {}

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

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

size_t PaymentsCustomerData::ByteSizeLong() const {}

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

void PaymentsCustomerData::MergeFrom(const PaymentsCustomerData& from) {}

void PaymentsCustomerData::CopyFrom(const PaymentsCustomerData& from) {}

bool PaymentsCustomerData::IsInitialized() const {}

void PaymentsCustomerData::InternalSwap(PaymentsCustomerData* other) {}

std::string PaymentsCustomerData::GetTypeName() const {}


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

class WalletCreditCardCloudTokenData::_Internal {};

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

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

WalletCreditCardCloudTokenData::~WalletCreditCardCloudTokenData() {}

inline void WalletCreditCardCloudTokenData::SharedDtor() {}

void WalletCreditCardCloudTokenData::SetCachedSize(int size) const {}

void WalletCreditCardCloudTokenData::Clear() {}

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

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

size_t WalletCreditCardCloudTokenData::ByteSizeLong() const {}

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

void WalletCreditCardCloudTokenData::MergeFrom(const WalletCreditCardCloudTokenData& from) {}

void WalletCreditCardCloudTokenData::CopyFrom(const WalletCreditCardCloudTokenData& from) {}

bool WalletCreditCardCloudTokenData::IsInitialized() const {}

void WalletCreditCardCloudTokenData::InternalSwap(WalletCreditCardCloudTokenData* other) {}

std::string WalletCreditCardCloudTokenData::GetTypeName() const {}


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

class PaymentInstrument::_Internal {};

const ::sync_pb::BankAccountDetails&
PaymentInstrument::_Internal::bank_account(const PaymentInstrument* msg) {}
const ::sync_pb::WalletMaskedIban&
PaymentInstrument::_Internal::iban(const PaymentInstrument* msg) {}
const ::sync_pb::EwalletDetails&
PaymentInstrument::_Internal::ewallet_details(const PaymentInstrument* msg) {}
const ::sync_pb::DeviceDetails&
PaymentInstrument::_Internal::device_details(const PaymentInstrument* msg) {}
void PaymentInstrument::set_allocated_bank_account(::sync_pb::BankAccountDetails* bank_account) {}
void PaymentInstrument::set_allocated_iban(::sync_pb::WalletMaskedIban* iban) {}
void PaymentInstrument::set_allocated_ewallet_details(::sync_pb::EwalletDetails* ewallet_details) {}
PaymentInstrument::PaymentInstrument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
PaymentInstrument::PaymentInstrument(const PaymentInstrument& from)
  :{}

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

PaymentInstrument::~PaymentInstrument() {}

inline void PaymentInstrument::SharedDtor() {}

void PaymentInstrument::SetCachedSize(int size) const {}

void PaymentInstrument::clear_instrument_details() {}


void PaymentInstrument::Clear() {}

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

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

size_t PaymentInstrument::ByteSizeLong() const {}

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

void PaymentInstrument::MergeFrom(const PaymentInstrument& from) {}

void PaymentInstrument::CopyFrom(const PaymentInstrument& from) {}

bool PaymentInstrument::IsInitialized() const {}

void PaymentInstrument::InternalSwap(PaymentInstrument* other) {}

std::string PaymentInstrument::GetTypeName() const {}


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

class WalletMaskedIban::_Internal {};

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

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

WalletMaskedIban::~WalletMaskedIban() {}

inline void WalletMaskedIban::SharedDtor() {}

void WalletMaskedIban::SetCachedSize(int size) const {}

void WalletMaskedIban::Clear() {}

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

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

size_t WalletMaskedIban::ByteSizeLong() const {}

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

void WalletMaskedIban::MergeFrom(const WalletMaskedIban& from) {}

void WalletMaskedIban::CopyFrom(const WalletMaskedIban& from) {}

bool WalletMaskedIban::IsInitialized() const {}

void WalletMaskedIban::InternalSwap(WalletMaskedIban* other) {}

std::string WalletMaskedIban::GetTypeName() const {}


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

class BankAccountDetails::_Internal {};

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

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

BankAccountDetails::~BankAccountDetails() {}

inline void BankAccountDetails::SharedDtor() {}

void BankAccountDetails::SetCachedSize(int size) const {}

void BankAccountDetails::Clear() {}

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

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

size_t BankAccountDetails::ByteSizeLong() const {}

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

void BankAccountDetails::MergeFrom(const BankAccountDetails& from) {}

void BankAccountDetails::CopyFrom(const BankAccountDetails& from) {}

bool BankAccountDetails::IsInitialized() const {}

void BankAccountDetails::InternalSwap(BankAccountDetails* other) {}

std::string BankAccountDetails::GetTypeName() const {}


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

class EwalletDetails::_Internal {};

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

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

EwalletDetails::~EwalletDetails() {}

inline void EwalletDetails::SharedDtor() {}

void EwalletDetails::SetCachedSize(int size) const {}

void EwalletDetails::Clear() {}

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

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

size_t EwalletDetails::ByteSizeLong() const {}

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

void EwalletDetails::MergeFrom(const EwalletDetails& from) {}

void EwalletDetails::CopyFrom(const EwalletDetails& from) {}

bool EwalletDetails::IsInitialized() const {}

void EwalletDetails::InternalSwap(EwalletDetails* other) {}

std::string EwalletDetails::GetTypeName() const {}


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

class DeviceDetails::_Internal {};

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

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

DeviceDetails::~DeviceDetails() {}

inline void DeviceDetails::SharedDtor() {}

void DeviceDetails::SetCachedSize(int size) const {}

void DeviceDetails::Clear() {}

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

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

size_t DeviceDetails::ByteSizeLong() const {}

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

void DeviceDetails::MergeFrom(const DeviceDetails& from) {}

void DeviceDetails::CopyFrom(const DeviceDetails& from) {}

bool DeviceDetails::IsInitialized() const {}

void DeviceDetails::InternalSwap(DeviceDetails* other) {}

std::string DeviceDetails::GetTypeName() const {}


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

class AutofillWalletSpecifics::_Internal {};

const ::sync_pb::WalletMaskedCreditCard&
AutofillWalletSpecifics::_Internal::masked_card(const AutofillWalletSpecifics* msg) {}
const ::sync_pb::WalletPostalAddress&
AutofillWalletSpecifics::_Internal::address(const AutofillWalletSpecifics* msg) {}
const ::sync_pb::PaymentsCustomerData&
AutofillWalletSpecifics::_Internal::customer_data(const AutofillWalletSpecifics* msg) {}
const ::sync_pb::WalletCreditCardCloudTokenData&
AutofillWalletSpecifics::_Internal::cloud_token_data(const AutofillWalletSpecifics* msg) {}
const ::sync_pb::PaymentInstrument&
AutofillWalletSpecifics::_Internal::payment_instrument(const AutofillWalletSpecifics* msg) {}
const ::sync_pb::WalletMaskedIban&
AutofillWalletSpecifics::_Internal::masked_iban(const AutofillWalletSpecifics* msg) {}
AutofillWalletSpecifics::AutofillWalletSpecifics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AutofillWalletSpecifics::AutofillWalletSpecifics(const AutofillWalletSpecifics& from)
  :{}

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

AutofillWalletSpecifics::~AutofillWalletSpecifics() {}

inline void AutofillWalletSpecifics::SharedDtor() {}

void AutofillWalletSpecifics::SetCachedSize(int size) const {}

void AutofillWalletSpecifics::Clear() {}

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

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

size_t AutofillWalletSpecifics::ByteSizeLong() const {}

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

void AutofillWalletSpecifics::MergeFrom(const AutofillWalletSpecifics& from) {}

void AutofillWalletSpecifics::CopyFrom(const AutofillWalletSpecifics& from) {}

bool AutofillWalletSpecifics::IsInitialized() const {}

void AutofillWalletSpecifics::InternalSwap(AutofillWalletSpecifics* other) {}

std::string AutofillWalletSpecifics::GetTypeName() const {}


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

class WalletMetadataSpecifics::_Internal {};

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

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

WalletMetadataSpecifics::~WalletMetadataSpecifics() {}

inline void WalletMetadataSpecifics::SharedDtor() {}

void WalletMetadataSpecifics::SetCachedSize(int size) const {}

void WalletMetadataSpecifics::Clear() {}

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

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

size_t WalletMetadataSpecifics::ByteSizeLong() const {}

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

void WalletMetadataSpecifics::MergeFrom(const WalletMetadataSpecifics& from) {}

void WalletMetadataSpecifics::CopyFrom(const WalletMetadataSpecifics& from) {}

bool WalletMetadataSpecifics::IsInitialized() const {}

void WalletMetadataSpecifics::InternalSwap(WalletMetadataSpecifics* other) {}

std::string WalletMetadataSpecifics::GetTypeName() const {}


// @@protoc_insertion_point(namespace_scope)
}  // namespace sync_pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sync_pb::AutofillProfileSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::AutofillProfileSpecifics >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::AutofillSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::AutofillSpecifics >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::CloudTokenData*
Arena::CreateMaybeMessage< ::sync_pb::CloudTokenData >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::CardBenefit_FlatRateBenefit*
Arena::CreateMaybeMessage< ::sync_pb::CardBenefit_FlatRateBenefit >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::CardBenefit_CategoryBenefit*
Arena::CreateMaybeMessage< ::sync_pb::CardBenefit_CategoryBenefit >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::CardBenefit_MerchantBenefit*
Arena::CreateMaybeMessage< ::sync_pb::CardBenefit_MerchantBenefit >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::CardBenefit*
Arena::CreateMaybeMessage< ::sync_pb::CardBenefit >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::CardIssuer*
Arena::CreateMaybeMessage< ::sync_pb::CardIssuer >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::WalletMaskedCreditCard*
Arena::CreateMaybeMessage< ::sync_pb::WalletMaskedCreditCard >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::WalletPostalAddress*
Arena::CreateMaybeMessage< ::sync_pb::WalletPostalAddress >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::PaymentsCustomerData*
Arena::CreateMaybeMessage< ::sync_pb::PaymentsCustomerData >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::WalletCreditCardCloudTokenData*
Arena::CreateMaybeMessage< ::sync_pb::WalletCreditCardCloudTokenData >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::PaymentInstrument*
Arena::CreateMaybeMessage< ::sync_pb::PaymentInstrument >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::WalletMaskedIban*
Arena::CreateMaybeMessage< ::sync_pb::WalletMaskedIban >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::BankAccountDetails*
Arena::CreateMaybeMessage< ::sync_pb::BankAccountDetails >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::EwalletDetails*
Arena::CreateMaybeMessage< ::sync_pb::EwalletDetails >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::DeviceDetails*
Arena::CreateMaybeMessage< ::sync_pb::DeviceDetails >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::AutofillWalletSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::AutofillWalletSpecifics >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::sync_pb::WalletMetadataSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::WalletMetadataSpecifics >(Arena* arena) {}
PROTOBUF_NAMESPACE_CLOSE

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