user.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: user/service/v1/user.proto

package v1

import (
	"bytes"
	"errors"
	"fmt"
	"net"
	"net/mail"
	"net/url"
	"regexp"
	"sort"
	"strings"
	"time"
	"unicode/utf8"

	"google.golang.org/protobuf/types/known/anypb"
)

// ensure the imports are used
var (
	_ = bytes.MinRead
	_ = errors.New("")
	_ = fmt.Print
	_ = utf8.UTFMax
	_ = (*regexp.Regexp)(nil)
	_ = (*strings.Reader)(nil)
	_ = net.IPv4len
	_ = time.Duration(0)
	_ = (*url.URL)(nil)
	_ = (*mail.Address)(nil)
	_ = anypb.Any{}
	_ = sort.Sort
)

// define the regex for a UUID once up-front
var _user_uuidPattern = regexp.MustCompile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")

// Validate checks the field values on UserRegisterReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UserRegisterReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserRegisterReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UserRegisterReqMultiError, or nil if none found.
func (m *UserRegisterReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UserRegisterReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if utf8.RuneCountInString(m.GetEmail()) > 50 {
		err := UserRegisterReqValidationError{
			field:  "Email",
			reason: "value length must be at most 50 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UserRegisterReq_Email_Pattern.MatchString(m.GetEmail()) {
		err := UserRegisterReqValidationError{
			field:  "Email",
			reason: "value does not match regex pattern \"\\\\w+([-+.]\\\\w+)*@\\\\w+([-.]\\\\w+)*\\\\.\\\\w+([-.]\\\\w+)*\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPassword()); l < 1 || l > 20 {
		err := UserRegisterReqValidationError{
			field:  "Password",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UserRegisterReq_Code_Pattern.MatchString(m.GetCode()) {
		err := UserRegisterReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]+$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return UserRegisterReqMultiError(errors)
	}

	return nil
}

// UserRegisterReqMultiError is an error wrapping multiple validation errors
// returned by UserRegisterReq.ValidateAll() if the designated constraints
// aren't met.
type UserRegisterReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UserRegisterReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UserRegisterReqMultiError) AllErrors() []error { return m }

// UserRegisterReqValidationError is the validation error returned by
// UserRegisterReq.Validate if the designated constraints aren't met.
type UserRegisterReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UserRegisterReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UserRegisterReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UserRegisterReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UserRegisterReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UserRegisterReqValidationError) ErrorName() string { return "UserRegisterReqValidationError" }

// Error satisfies the builtin error interface
func (e UserRegisterReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sUserRegisterReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserRegisterReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UserRegisterReqValidationError{}

var _UserRegisterReq_Email_Pattern = regexp.MustCompile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*")

var _UserRegisterReq_Code_Pattern = regexp.MustCompile("^[0-9]+$")

// Validate checks the field values on AvatarIrregularReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *AvatarIrregularReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on AvatarIrregularReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// AvatarIrregularReqMultiError, or nil if none found.
func (m *AvatarIrregularReq) ValidateAll() error {
	return m.validate(true)
}

func (m *AvatarIrregularReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = AvatarIrregularReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetJobId()) > 1000 {
		err := AvatarIrregularReqValidationError{
			field:  "JobId",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetUrl()) > 1000 {
		err := AvatarIrregularReqValidationError{
			field:  "Url",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetLabel()) > 1000 {
		err := AvatarIrregularReqValidationError{
			field:  "Label",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Result

	// no validation rules for Score

	if utf8.RuneCountInString(m.GetCategory()) > 1000 {
		err := AvatarIrregularReqValidationError{
			field:  "Category",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetSubLabel()) > 1000 {
		err := AvatarIrregularReqValidationError{
			field:  "SubLabel",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return AvatarIrregularReqMultiError(errors)
	}

	return nil
}

func (m *AvatarIrregularReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// AvatarIrregularReqMultiError is an error wrapping multiple validation errors
// returned by AvatarIrregularReq.ValidateAll() if the designated constraints
// aren't met.
type AvatarIrregularReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m AvatarIrregularReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m AvatarIrregularReqMultiError) AllErrors() []error { return m }

// AvatarIrregularReqValidationError is the validation error returned by
// AvatarIrregularReq.Validate if the designated constraints aren't met.
type AvatarIrregularReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e AvatarIrregularReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e AvatarIrregularReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e AvatarIrregularReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e AvatarIrregularReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e AvatarIrregularReqValidationError) ErrorName() string {
	return "AvatarIrregularReqValidationError"
}

// Error satisfies the builtin error interface
func (e AvatarIrregularReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sAvatarIrregularReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AvatarIrregularReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = AvatarIrregularReqValidationError{}

// Validate checks the field values on AddAvatarReviewDbAndCacheReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *AddAvatarReviewDbAndCacheReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on AddAvatarReviewDbAndCacheReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// AddAvatarReviewDbAndCacheReqMultiError, or nil if none found.
func (m *AddAvatarReviewDbAndCacheReq) ValidateAll() error {
	return m.validate(true)
}

func (m *AddAvatarReviewDbAndCacheReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for JobId

	// no validation rules for Url

	// no validation rules for Label

	// no validation rules for Result

	// no validation rules for Score

	// no validation rules for Category

	// no validation rules for SubLabel

	if len(errors) > 0 {
		return AddAvatarReviewDbAndCacheReqMultiError(errors)
	}

	return nil
}

// AddAvatarReviewDbAndCacheReqMultiError is an error wrapping multiple
// validation errors returned by AddAvatarReviewDbAndCacheReq.ValidateAll() if
// the designated constraints aren't met.
type AddAvatarReviewDbAndCacheReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m AddAvatarReviewDbAndCacheReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m AddAvatarReviewDbAndCacheReqMultiError) AllErrors() []error { return m }

// AddAvatarReviewDbAndCacheReqValidationError is the validation error returned
// by AddAvatarReviewDbAndCacheReq.Validate if the designated constraints
// aren't met.
type AddAvatarReviewDbAndCacheReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e AddAvatarReviewDbAndCacheReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e AddAvatarReviewDbAndCacheReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e AddAvatarReviewDbAndCacheReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e AddAvatarReviewDbAndCacheReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e AddAvatarReviewDbAndCacheReqValidationError) ErrorName() string {
	return "AddAvatarReviewDbAndCacheReqValidationError"
}

// Error satisfies the builtin error interface
func (e AddAvatarReviewDbAndCacheReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sAddAvatarReviewDbAndCacheReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AddAvatarReviewDbAndCacheReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = AddAvatarReviewDbAndCacheReqValidationError{}

// Validate checks the field values on CoverIrregularReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *CoverIrregularReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CoverIrregularReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CoverIrregularReqMultiError, or nil if none found.
func (m *CoverIrregularReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CoverIrregularReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = CoverIrregularReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetJobId()) > 1000 {
		err := CoverIrregularReqValidationError{
			field:  "JobId",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetUrl()) > 1000 {
		err := CoverIrregularReqValidationError{
			field:  "Url",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetLabel()) > 1000 {
		err := CoverIrregularReqValidationError{
			field:  "Label",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Result

	// no validation rules for Score

	if utf8.RuneCountInString(m.GetCategory()) > 1000 {
		err := CoverIrregularReqValidationError{
			field:  "Category",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetSubLabel()) > 1000 {
		err := CoverIrregularReqValidationError{
			field:  "SubLabel",
			reason: "value length must be at most 1000 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return CoverIrregularReqMultiError(errors)
	}

	return nil
}

func (m *CoverIrregularReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// CoverIrregularReqMultiError is an error wrapping multiple validation errors
// returned by CoverIrregularReq.ValidateAll() if the designated constraints
// aren't met.
type CoverIrregularReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CoverIrregularReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CoverIrregularReqMultiError) AllErrors() []error { return m }

// CoverIrregularReqValidationError is the validation error returned by
// CoverIrregularReq.Validate if the designated constraints aren't met.
type CoverIrregularReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CoverIrregularReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CoverIrregularReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CoverIrregularReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CoverIrregularReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CoverIrregularReqValidationError) ErrorName() string {
	return "CoverIrregularReqValidationError"
}

// Error satisfies the builtin error interface
func (e CoverIrregularReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCoverIrregularReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CoverIrregularReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CoverIrregularReqValidationError{}

// Validate checks the field values on AddCoverReviewDbAndCacheReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *AddCoverReviewDbAndCacheReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on AddCoverReviewDbAndCacheReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// AddCoverReviewDbAndCacheReqMultiError, or nil if none found.
func (m *AddCoverReviewDbAndCacheReq) ValidateAll() error {
	return m.validate(true)
}

func (m *AddCoverReviewDbAndCacheReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for JobId

	// no validation rules for Url

	// no validation rules for Label

	// no validation rules for Result

	// no validation rules for Score

	// no validation rules for Category

	// no validation rules for SubLabel

	if len(errors) > 0 {
		return AddCoverReviewDbAndCacheReqMultiError(errors)
	}

	return nil
}

// AddCoverReviewDbAndCacheReqMultiError is an error wrapping multiple
// validation errors returned by AddCoverReviewDbAndCacheReq.ValidateAll() if
// the designated constraints aren't met.
type AddCoverReviewDbAndCacheReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m AddCoverReviewDbAndCacheReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m AddCoverReviewDbAndCacheReqMultiError) AllErrors() []error { return m }

// AddCoverReviewDbAndCacheReqValidationError is the validation error returned
// by AddCoverReviewDbAndCacheReq.Validate if the designated constraints
// aren't met.
type AddCoverReviewDbAndCacheReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e AddCoverReviewDbAndCacheReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e AddCoverReviewDbAndCacheReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e AddCoverReviewDbAndCacheReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e AddCoverReviewDbAndCacheReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e AddCoverReviewDbAndCacheReqValidationError) ErrorName() string {
	return "AddCoverReviewDbAndCacheReqValidationError"
}

// Error satisfies the builtin error interface
func (e AddCoverReviewDbAndCacheReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sAddCoverReviewDbAndCacheReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AddCoverReviewDbAndCacheReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = AddCoverReviewDbAndCacheReqValidationError{}

// Validate checks the field values on LoginByPasswordReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *LoginByPasswordReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LoginByPasswordReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// LoginByPasswordReqMultiError, or nil if none found.
func (m *LoginByPasswordReq) ValidateAll() error {
	return m.validate(true)
}

func (m *LoginByPasswordReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if utf8.RuneCountInString(m.GetAccount()) > 50 {
		err := LoginByPasswordReqValidationError{
			field:  "Account",
			reason: "value length must be at most 50 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_LoginByPasswordReq_Account_Pattern.MatchString(m.GetAccount()) {
		err := LoginByPasswordReqValidationError{
			field:  "Account",
			reason: "value does not match regex pattern \"^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\\\d{8}$|\\\\w+([-+.]\\\\w+)*@\\\\w+([-.]\\\\w+)*\\\\.\\\\w+([-.]\\\\w+)*\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPassword()); l < 1 || l > 20 {
		err := LoginByPasswordReqValidationError{
			field:  "Password",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if _, ok := _LoginByPasswordReq_Mode_InLookup[m.GetMode()]; !ok {
		err := LoginByPasswordReqValidationError{
			field:  "Mode",
			reason: "value must be in list [phone email]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return LoginByPasswordReqMultiError(errors)
	}

	return nil
}

// LoginByPasswordReqMultiError is an error wrapping multiple validation errors
// returned by LoginByPasswordReq.ValidateAll() if the designated constraints
// aren't met.
type LoginByPasswordReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LoginByPasswordReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m LoginByPasswordReqMultiError) AllErrors() []error { return m }

// LoginByPasswordReqValidationError is the validation error returned by
// LoginByPasswordReq.Validate if the designated constraints aren't met.
type LoginByPasswordReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LoginByPasswordReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LoginByPasswordReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LoginByPasswordReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LoginByPasswordReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LoginByPasswordReqValidationError) ErrorName() string {
	return "LoginByPasswordReqValidationError"
}

// Error satisfies the builtin error interface
func (e LoginByPasswordReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sLoginByPasswordReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LoginByPasswordReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LoginByPasswordReqValidationError{}

var _LoginByPasswordReq_Account_Pattern = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$|\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*")

var _LoginByPasswordReq_Mode_InLookup = map[string]struct{}{
	"phone": {},
	"email": {},
}

// Validate checks the field values on LoginByCodeReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *LoginByCodeReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LoginByCodeReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in LoginByCodeReqMultiError,
// or nil if none found.
func (m *LoginByCodeReq) ValidateAll() error {
	return m.validate(true)
}

func (m *LoginByCodeReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if !_LoginByCodeReq_Phone_Pattern.MatchString(m.GetPhone()) {
		err := LoginByCodeReqValidationError{
			field:  "Phone",
			reason: "value does not match regex pattern \"^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\\\d{8}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_LoginByCodeReq_Code_Pattern.MatchString(m.GetCode()) {
		err := LoginByCodeReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]{6}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return LoginByCodeReqMultiError(errors)
	}

	return nil
}

// LoginByCodeReqMultiError is an error wrapping multiple validation errors
// returned by LoginByCodeReq.ValidateAll() if the designated constraints
// aren't met.
type LoginByCodeReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LoginByCodeReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m LoginByCodeReqMultiError) AllErrors() []error { return m }

// LoginByCodeReqValidationError is the validation error returned by
// LoginByCodeReq.Validate if the designated constraints aren't met.
type LoginByCodeReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LoginByCodeReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LoginByCodeReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LoginByCodeReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LoginByCodeReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LoginByCodeReqValidationError) ErrorName() string { return "LoginByCodeReqValidationError" }

// Error satisfies the builtin error interface
func (e LoginByCodeReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sLoginByCodeReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LoginByCodeReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LoginByCodeReqValidationError{}

var _LoginByCodeReq_Phone_Pattern = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$")

var _LoginByCodeReq_Code_Pattern = regexp.MustCompile("^[0-9]{6}$")

// Validate checks the field values on LoginReply with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *LoginReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LoginReply with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in LoginReplyMultiError, or
// nil if none found.
func (m *LoginReply) ValidateAll() error {
	return m.validate(true)
}

func (m *LoginReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Token

	if len(errors) > 0 {
		return LoginReplyMultiError(errors)
	}

	return nil
}

// LoginReplyMultiError is an error wrapping multiple validation errors
// returned by LoginReply.ValidateAll() if the designated constraints aren't met.
type LoginReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LoginReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m LoginReplyMultiError) AllErrors() []error { return m }

// LoginReplyValidationError is the validation error returned by
// LoginReply.Validate if the designated constraints aren't met.
type LoginReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LoginReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LoginReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LoginReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LoginReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LoginReplyValidationError) ErrorName() string { return "LoginReplyValidationError" }

// Error satisfies the builtin error interface
func (e LoginReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sLoginReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LoginReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LoginReplyValidationError{}

// Validate checks the field values on LoginByWeChatReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *LoginByWeChatReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LoginByWeChatReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// LoginByWeChatReqMultiError, or nil if none found.
func (m *LoginByWeChatReq) ValidateAll() error {
	return m.validate(true)
}

func (m *LoginByWeChatReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Wechat

	if len(errors) > 0 {
		return LoginByWeChatReqMultiError(errors)
	}

	return nil
}

// LoginByWeChatReqMultiError is an error wrapping multiple validation errors
// returned by LoginByWeChatReq.ValidateAll() if the designated constraints
// aren't met.
type LoginByWeChatReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LoginByWeChatReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m LoginByWeChatReqMultiError) AllErrors() []error { return m }

// LoginByWeChatReqValidationError is the validation error returned by
// LoginByWeChatReq.Validate if the designated constraints aren't met.
type LoginByWeChatReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LoginByWeChatReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LoginByWeChatReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LoginByWeChatReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LoginByWeChatReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LoginByWeChatReqValidationError) ErrorName() string { return "LoginByWeChatReqValidationError" }

// Error satisfies the builtin error interface
func (e LoginByWeChatReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sLoginByWeChatReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LoginByWeChatReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LoginByWeChatReqValidationError{}

// Validate checks the field values on LoginByGithubReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *LoginByGithubReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LoginByGithubReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// LoginByGithubReqMultiError, or nil if none found.
func (m *LoginByGithubReq) ValidateAll() error {
	return m.validate(true)
}

func (m *LoginByGithubReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Github

	if len(errors) > 0 {
		return LoginByGithubReqMultiError(errors)
	}

	return nil
}

// LoginByGithubReqMultiError is an error wrapping multiple validation errors
// returned by LoginByGithubReq.ValidateAll() if the designated constraints
// aren't met.
type LoginByGithubReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LoginByGithubReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m LoginByGithubReqMultiError) AllErrors() []error { return m }

// LoginByGithubReqValidationError is the validation error returned by
// LoginByGithubReq.Validate if the designated constraints aren't met.
type LoginByGithubReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LoginByGithubReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LoginByGithubReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LoginByGithubReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LoginByGithubReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LoginByGithubReqValidationError) ErrorName() string { return "LoginByGithubReqValidationError" }

// Error satisfies the builtin error interface
func (e LoginByGithubReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sLoginByGithubReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LoginByGithubReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LoginByGithubReqValidationError{}

// Validate checks the field values on LoginPasswordResetReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *LoginPasswordResetReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LoginPasswordResetReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// LoginPasswordResetReqMultiError, or nil if none found.
func (m *LoginPasswordResetReq) ValidateAll() error {
	return m.validate(true)
}

func (m *LoginPasswordResetReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if utf8.RuneCountInString(m.GetAccount()) > 50 {
		err := LoginPasswordResetReqValidationError{
			field:  "Account",
			reason: "value length must be at most 50 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_LoginPasswordResetReq_Account_Pattern.MatchString(m.GetAccount()) {
		err := LoginPasswordResetReqValidationError{
			field:  "Account",
			reason: "value does not match regex pattern \"^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\\\d{8}$|\\\\w+([-+.]\\\\w+)*@\\\\w+([-.]\\\\w+)*\\\\.\\\\w+([-.]\\\\w+)*\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_LoginPasswordResetReq_Code_Pattern.MatchString(m.GetCode()) {
		err := LoginPasswordResetReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]{6}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPassword()); l < 1 || l > 20 {
		err := LoginPasswordResetReqValidationError{
			field:  "Password",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if _, ok := _LoginPasswordResetReq_Mode_InLookup[m.GetMode()]; !ok {
		err := LoginPasswordResetReqValidationError{
			field:  "Mode",
			reason: "value must be in list [phone email]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return LoginPasswordResetReqMultiError(errors)
	}

	return nil
}

// LoginPasswordResetReqMultiError is an error wrapping multiple validation
// errors returned by LoginPasswordResetReq.ValidateAll() if the designated
// constraints aren't met.
type LoginPasswordResetReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LoginPasswordResetReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m LoginPasswordResetReqMultiError) AllErrors() []error { return m }

// LoginPasswordResetReqValidationError is the validation error returned by
// LoginPasswordResetReq.Validate if the designated constraints aren't met.
type LoginPasswordResetReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LoginPasswordResetReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LoginPasswordResetReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LoginPasswordResetReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LoginPasswordResetReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LoginPasswordResetReqValidationError) ErrorName() string {
	return "LoginPasswordResetReqValidationError"
}

// Error satisfies the builtin error interface
func (e LoginPasswordResetReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sLoginPasswordResetReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LoginPasswordResetReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LoginPasswordResetReqValidationError{}

var _LoginPasswordResetReq_Account_Pattern = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$|\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*")

var _LoginPasswordResetReq_Code_Pattern = regexp.MustCompile("^[0-9]{6}$")

var _LoginPasswordResetReq_Mode_InLookup = map[string]struct{}{
	"phone": {},
	"email": {},
}

// Validate checks the field values on SendPhoneCodeReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *SendPhoneCodeReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SendPhoneCodeReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SendPhoneCodeReqMultiError, or nil if none found.
func (m *SendPhoneCodeReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SendPhoneCodeReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if l := utf8.RuneCountInString(m.GetPhone()); l < 1 || l > 50 {
		err := SendPhoneCodeReqValidationError{
			field:  "Phone",
			reason: "value length must be between 1 and 50 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_SendPhoneCodeReq_Phone_Pattern.MatchString(m.GetPhone()) {
		err := SendPhoneCodeReqValidationError{
			field:  "Phone",
			reason: "value does not match regex pattern \"^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\\\d{8}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if _, ok := _SendPhoneCodeReq_Template_InLookup[m.GetTemplate()]; !ok {
		err := SendPhoneCodeReqValidationError{
			field:  "Template",
			reason: "value must be in list [1 2 3 4]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SendPhoneCodeReqMultiError(errors)
	}

	return nil
}

// SendPhoneCodeReqMultiError is an error wrapping multiple validation errors
// returned by SendPhoneCodeReq.ValidateAll() if the designated constraints
// aren't met.
type SendPhoneCodeReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SendPhoneCodeReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SendPhoneCodeReqMultiError) AllErrors() []error { return m }

// SendPhoneCodeReqValidationError is the validation error returned by
// SendPhoneCodeReq.Validate if the designated constraints aren't met.
type SendPhoneCodeReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SendPhoneCodeReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SendPhoneCodeReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SendPhoneCodeReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SendPhoneCodeReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SendPhoneCodeReqValidationError) ErrorName() string { return "SendPhoneCodeReqValidationError" }

// Error satisfies the builtin error interface
func (e SendPhoneCodeReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSendPhoneCodeReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SendPhoneCodeReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SendPhoneCodeReqValidationError{}

var _SendPhoneCodeReq_Phone_Pattern = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$")

var _SendPhoneCodeReq_Template_InLookup = map[string]struct{}{
	"1": {},
	"2": {},
	"3": {},
	"4": {},
}

// Validate checks the field values on SendEmailCodeReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *SendEmailCodeReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SendEmailCodeReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SendEmailCodeReqMultiError, or nil if none found.
func (m *SendEmailCodeReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SendEmailCodeReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if utf8.RuneCountInString(m.GetEmail()) > 50 {
		err := SendEmailCodeReqValidationError{
			field:  "Email",
			reason: "value length must be at most 50 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_SendEmailCodeReq_Email_Pattern.MatchString(m.GetEmail()) {
		err := SendEmailCodeReqValidationError{
			field:  "Email",
			reason: "value does not match regex pattern \"\\\\w+([-+.]\\\\w+)*@\\\\w+([-.]\\\\w+)*\\\\.\\\\w+([-.]\\\\w+)*\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if _, ok := _SendEmailCodeReq_Template_InLookup[m.GetTemplate()]; !ok {
		err := SendEmailCodeReqValidationError{
			field:  "Template",
			reason: "value must be in list [1 2 3 4 5]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SendEmailCodeReqMultiError(errors)
	}

	return nil
}

// SendEmailCodeReqMultiError is an error wrapping multiple validation errors
// returned by SendEmailCodeReq.ValidateAll() if the designated constraints
// aren't met.
type SendEmailCodeReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SendEmailCodeReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SendEmailCodeReqMultiError) AllErrors() []error { return m }

// SendEmailCodeReqValidationError is the validation error returned by
// SendEmailCodeReq.Validate if the designated constraints aren't met.
type SendEmailCodeReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SendEmailCodeReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SendEmailCodeReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SendEmailCodeReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SendEmailCodeReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SendEmailCodeReqValidationError) ErrorName() string { return "SendEmailCodeReqValidationError" }

// Error satisfies the builtin error interface
func (e SendEmailCodeReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSendEmailCodeReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SendEmailCodeReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SendEmailCodeReqValidationError{}

var _SendEmailCodeReq_Email_Pattern = regexp.MustCompile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*")

var _SendEmailCodeReq_Template_InLookup = map[string]struct{}{
	"1": {},
	"2": {},
	"3": {},
	"4": {},
	"5": {},
}

// Validate checks the field values on GetCosSessionKeyReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCosSessionKeyReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCosSessionKeyReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetCosSessionKeyReqMultiError, or nil if none found.
func (m *GetCosSessionKeyReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCosSessionKeyReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetCosSessionKeyReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetCosSessionKeyReqMultiError(errors)
	}

	return nil
}

func (m *GetCosSessionKeyReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetCosSessionKeyReqMultiError is an error wrapping multiple validation
// errors returned by GetCosSessionKeyReq.ValidateAll() if the designated
// constraints aren't met.
type GetCosSessionKeyReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCosSessionKeyReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCosSessionKeyReqMultiError) AllErrors() []error { return m }

// GetCosSessionKeyReqValidationError is the validation error returned by
// GetCosSessionKeyReq.Validate if the designated constraints aren't met.
type GetCosSessionKeyReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCosSessionKeyReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCosSessionKeyReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCosSessionKeyReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCosSessionKeyReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCosSessionKeyReqValidationError) ErrorName() string {
	return "GetCosSessionKeyReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetCosSessionKeyReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetCosSessionKeyReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCosSessionKeyReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCosSessionKeyReqValidationError{}

// Validate checks the field values on GetCosSessionKeyReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCosSessionKeyReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCosSessionKeyReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetCosSessionKeyReplyMultiError, or nil if none found.
func (m *GetCosSessionKeyReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCosSessionKeyReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for TmpSecretId

	// no validation rules for TmpSecretKey

	// no validation rules for SessionToken

	// no validation rules for StartTime

	// no validation rules for ExpiredTime

	if len(errors) > 0 {
		return GetCosSessionKeyReplyMultiError(errors)
	}

	return nil
}

// GetCosSessionKeyReplyMultiError is an error wrapping multiple validation
// errors returned by GetCosSessionKeyReply.ValidateAll() if the designated
// constraints aren't met.
type GetCosSessionKeyReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCosSessionKeyReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCosSessionKeyReplyMultiError) AllErrors() []error { return m }

// GetCosSessionKeyReplyValidationError is the validation error returned by
// GetCosSessionKeyReply.Validate if the designated constraints aren't met.
type GetCosSessionKeyReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCosSessionKeyReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCosSessionKeyReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCosSessionKeyReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCosSessionKeyReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCosSessionKeyReplyValidationError) ErrorName() string {
	return "GetCosSessionKeyReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetCosSessionKeyReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetCosSessionKeyReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCosSessionKeyReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCosSessionKeyReplyValidationError{}

// Validate checks the field values on SetUserPhoneReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *SetUserPhoneReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetUserPhoneReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SetUserPhoneReqMultiError, or nil if none found.
func (m *SetUserPhoneReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetUserPhoneReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SetUserPhoneReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPhone()); l < 1 || l > 50 {
		err := SetUserPhoneReqValidationError{
			field:  "Phone",
			reason: "value length must be between 1 and 50 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_SetUserPhoneReq_Phone_Pattern.MatchString(m.GetPhone()) {
		err := SetUserPhoneReqValidationError{
			field:  "Phone",
			reason: "value does not match regex pattern \"^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\\\d{8}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_SetUserPhoneReq_Code_Pattern.MatchString(m.GetCode()) {
		err := SetUserPhoneReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]{6}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SetUserPhoneReqMultiError(errors)
	}

	return nil
}

func (m *SetUserPhoneReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// SetUserPhoneReqMultiError is an error wrapping multiple validation errors
// returned by SetUserPhoneReq.ValidateAll() if the designated constraints
// aren't met.
type SetUserPhoneReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetUserPhoneReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetUserPhoneReqMultiError) AllErrors() []error { return m }

// SetUserPhoneReqValidationError is the validation error returned by
// SetUserPhoneReq.Validate if the designated constraints aren't met.
type SetUserPhoneReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SetUserPhoneReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SetUserPhoneReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SetUserPhoneReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SetUserPhoneReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SetUserPhoneReqValidationError) ErrorName() string { return "SetUserPhoneReqValidationError" }

// Error satisfies the builtin error interface
func (e SetUserPhoneReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSetUserPhoneReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetUserPhoneReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SetUserPhoneReqValidationError{}

var _SetUserPhoneReq_Phone_Pattern = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$")

var _SetUserPhoneReq_Code_Pattern = regexp.MustCompile("^[0-9]{6}$")

// Validate checks the field values on SetUserEmailReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *SetUserEmailReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetUserEmailReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SetUserEmailReqMultiError, or nil if none found.
func (m *SetUserEmailReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetUserEmailReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SetUserEmailReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetEmail()) > 50 {
		err := SetUserEmailReqValidationError{
			field:  "Email",
			reason: "value length must be at most 50 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_SetUserEmailReq_Email_Pattern.MatchString(m.GetEmail()) {
		err := SetUserEmailReqValidationError{
			field:  "Email",
			reason: "value does not match regex pattern \"\\\\w+([-+.]\\\\w+)*@\\\\w+([-.]\\\\w+)*\\\\.\\\\w+([-.]\\\\w+)*\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_SetUserEmailReq_Code_Pattern.MatchString(m.GetCode()) {
		err := SetUserEmailReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]{6}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SetUserEmailReqMultiError(errors)
	}

	return nil
}

func (m *SetUserEmailReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// SetUserEmailReqMultiError is an error wrapping multiple validation errors
// returned by SetUserEmailReq.ValidateAll() if the designated constraints
// aren't met.
type SetUserEmailReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetUserEmailReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetUserEmailReqMultiError) AllErrors() []error { return m }

// SetUserEmailReqValidationError is the validation error returned by
// SetUserEmailReq.Validate if the designated constraints aren't met.
type SetUserEmailReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SetUserEmailReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SetUserEmailReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SetUserEmailReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SetUserEmailReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SetUserEmailReqValidationError) ErrorName() string { return "SetUserEmailReqValidationError" }

// Error satisfies the builtin error interface
func (e SetUserEmailReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSetUserEmailReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetUserEmailReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SetUserEmailReqValidationError{}

var _SetUserEmailReq_Email_Pattern = regexp.MustCompile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*")

var _SetUserEmailReq_Code_Pattern = regexp.MustCompile("^[0-9]{6}$")

// Validate checks the field values on SetUserPasswordReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *SetUserPasswordReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetUserPasswordReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SetUserPasswordReqMultiError, or nil if none found.
func (m *SetUserPasswordReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetUserPasswordReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SetUserPasswordReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPassword()); l < 1 || l > 20 {
		err := SetUserPasswordReqValidationError{
			field:  "Password",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SetUserPasswordReqMultiError(errors)
	}

	return nil
}

func (m *SetUserPasswordReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// SetUserPasswordReqMultiError is an error wrapping multiple validation errors
// returned by SetUserPasswordReq.ValidateAll() if the designated constraints
// aren't met.
type SetUserPasswordReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetUserPasswordReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetUserPasswordReqMultiError) AllErrors() []error { return m }

// SetUserPasswordReqValidationError is the validation error returned by
// SetUserPasswordReq.Validate if the designated constraints aren't met.
type SetUserPasswordReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SetUserPasswordReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SetUserPasswordReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SetUserPasswordReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SetUserPasswordReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SetUserPasswordReqValidationError) ErrorName() string {
	return "SetUserPasswordReqValidationError"
}

// Error satisfies the builtin error interface
func (e SetUserPasswordReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSetUserPasswordReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetUserPasswordReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SetUserPasswordReqValidationError{}

// Validate checks the field values on SetUserFollowReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *SetUserFollowReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetUserFollowReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SetUserFollowReqMultiError, or nil if none found.
func (m *SetUserFollowReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetUserFollowReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SetUserFollowReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if err := m._validateUuid(m.GetUserUuid()); err != nil {
		err = SetUserFollowReqValidationError{
			field:  "UserUuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SetUserFollowReqMultiError(errors)
	}

	return nil
}

func (m *SetUserFollowReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// SetUserFollowReqMultiError is an error wrapping multiple validation errors
// returned by SetUserFollowReq.ValidateAll() if the designated constraints
// aren't met.
type SetUserFollowReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetUserFollowReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetUserFollowReqMultiError) AllErrors() []error { return m }

// SetUserFollowReqValidationError is the validation error returned by
// SetUserFollowReq.Validate if the designated constraints aren't met.
type SetUserFollowReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SetUserFollowReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SetUserFollowReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SetUserFollowReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SetUserFollowReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SetUserFollowReqValidationError) ErrorName() string { return "SetUserFollowReqValidationError" }

// Error satisfies the builtin error interface
func (e SetUserFollowReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSetUserFollowReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetUserFollowReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SetUserFollowReqValidationError{}

// Validate checks the field values on SetFollowDbAndCacheReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *SetFollowDbAndCacheReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetFollowDbAndCacheReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SetFollowDbAndCacheReqMultiError, or nil if none found.
func (m *SetFollowDbAndCacheReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetFollowDbAndCacheReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SetFollowDbAndCacheReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if err := m._validateUuid(m.GetUserUuid()); err != nil {
		err = SetFollowDbAndCacheReqValidationError{
			field:  "UserUuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SetFollowDbAndCacheReqMultiError(errors)
	}

	return nil
}

func (m *SetFollowDbAndCacheReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// SetFollowDbAndCacheReqMultiError is an error wrapping multiple validation
// errors returned by SetFollowDbAndCacheReq.ValidateAll() if the designated
// constraints aren't met.
type SetFollowDbAndCacheReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetFollowDbAndCacheReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetFollowDbAndCacheReqMultiError) AllErrors() []error { return m }

// SetFollowDbAndCacheReqValidationError is the validation error returned by
// SetFollowDbAndCacheReq.Validate if the designated constraints aren't met.
type SetFollowDbAndCacheReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SetFollowDbAndCacheReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SetFollowDbAndCacheReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SetFollowDbAndCacheReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SetFollowDbAndCacheReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SetFollowDbAndCacheReqValidationError) ErrorName() string {
	return "SetFollowDbAndCacheReqValidationError"
}

// Error satisfies the builtin error interface
func (e SetFollowDbAndCacheReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSetFollowDbAndCacheReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetFollowDbAndCacheReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SetFollowDbAndCacheReqValidationError{}

// Validate checks the field values on CancelUserFollowReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CancelUserFollowReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CancelUserFollowReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CancelUserFollowReqMultiError, or nil if none found.
func (m *CancelUserFollowReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CancelUserFollowReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = CancelUserFollowReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if err := m._validateUuid(m.GetUserUuid()); err != nil {
		err = CancelUserFollowReqValidationError{
			field:  "UserUuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return CancelUserFollowReqMultiError(errors)
	}

	return nil
}

func (m *CancelUserFollowReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// CancelUserFollowReqMultiError is an error wrapping multiple validation
// errors returned by CancelUserFollowReq.ValidateAll() if the designated
// constraints aren't met.
type CancelUserFollowReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CancelUserFollowReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CancelUserFollowReqMultiError) AllErrors() []error { return m }

// CancelUserFollowReqValidationError is the validation error returned by
// CancelUserFollowReq.Validate if the designated constraints aren't met.
type CancelUserFollowReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CancelUserFollowReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CancelUserFollowReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CancelUserFollowReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CancelUserFollowReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CancelUserFollowReqValidationError) ErrorName() string {
	return "CancelUserFollowReqValidationError"
}

// Error satisfies the builtin error interface
func (e CancelUserFollowReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCancelUserFollowReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CancelUserFollowReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CancelUserFollowReqValidationError{}

// Validate checks the field values on CancelFollowDbAndCacheReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CancelFollowDbAndCacheReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CancelFollowDbAndCacheReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CancelFollowDbAndCacheReqMultiError, or nil if none found.
func (m *CancelFollowDbAndCacheReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CancelFollowDbAndCacheReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = CancelFollowDbAndCacheReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if err := m._validateUuid(m.GetUserUuid()); err != nil {
		err = CancelFollowDbAndCacheReqValidationError{
			field:  "UserUuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return CancelFollowDbAndCacheReqMultiError(errors)
	}

	return nil
}

func (m *CancelFollowDbAndCacheReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// CancelFollowDbAndCacheReqMultiError is an error wrapping multiple validation
// errors returned by CancelFollowDbAndCacheReq.ValidateAll() if the
// designated constraints aren't met.
type CancelFollowDbAndCacheReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CancelFollowDbAndCacheReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CancelFollowDbAndCacheReqMultiError) AllErrors() []error { return m }

// CancelFollowDbAndCacheReqValidationError is the validation error returned by
// CancelFollowDbAndCacheReq.Validate if the designated constraints aren't met.
type CancelFollowDbAndCacheReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CancelFollowDbAndCacheReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CancelFollowDbAndCacheReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CancelFollowDbAndCacheReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CancelFollowDbAndCacheReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CancelFollowDbAndCacheReqValidationError) ErrorName() string {
	return "CancelFollowDbAndCacheReqValidationError"
}

// Error satisfies the builtin error interface
func (e CancelFollowDbAndCacheReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCancelFollowDbAndCacheReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CancelFollowDbAndCacheReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CancelFollowDbAndCacheReqValidationError{}

// Validate checks the field values on ChangeUserPasswordReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ChangeUserPasswordReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ChangeUserPasswordReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ChangeUserPasswordReqMultiError, or nil if none found.
func (m *ChangeUserPasswordReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ChangeUserPasswordReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ChangeUserPasswordReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetOldpassword()); l < 1 || l > 20 {
		err := ChangeUserPasswordReqValidationError{
			field:  "Oldpassword",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPassword()); l < 1 || l > 20 {
		err := ChangeUserPasswordReqValidationError{
			field:  "Password",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return ChangeUserPasswordReqMultiError(errors)
	}

	return nil
}

func (m *ChangeUserPasswordReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// ChangeUserPasswordReqMultiError is an error wrapping multiple validation
// errors returned by ChangeUserPasswordReq.ValidateAll() if the designated
// constraints aren't met.
type ChangeUserPasswordReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ChangeUserPasswordReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ChangeUserPasswordReqMultiError) AllErrors() []error { return m }

// ChangeUserPasswordReqValidationError is the validation error returned by
// ChangeUserPasswordReq.Validate if the designated constraints aren't met.
type ChangeUserPasswordReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ChangeUserPasswordReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ChangeUserPasswordReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ChangeUserPasswordReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ChangeUserPasswordReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ChangeUserPasswordReqValidationError) ErrorName() string {
	return "ChangeUserPasswordReqValidationError"
}

// Error satisfies the builtin error interface
func (e ChangeUserPasswordReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sChangeUserPasswordReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ChangeUserPasswordReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ChangeUserPasswordReqValidationError{}

// Validate checks the field values on UnbindUserPhoneReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UnbindUserPhoneReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UnbindUserPhoneReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UnbindUserPhoneReqMultiError, or nil if none found.
func (m *UnbindUserPhoneReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UnbindUserPhoneReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = UnbindUserPhoneReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetPhone()); l < 1 || l > 50 {
		err := UnbindUserPhoneReqValidationError{
			field:  "Phone",
			reason: "value length must be between 1 and 50 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UnbindUserPhoneReq_Phone_Pattern.MatchString(m.GetPhone()) {
		err := UnbindUserPhoneReqValidationError{
			field:  "Phone",
			reason: "value does not match regex pattern \"^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\\\d{8}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UnbindUserPhoneReq_Code_Pattern.MatchString(m.GetCode()) {
		err := UnbindUserPhoneReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]{6}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return UnbindUserPhoneReqMultiError(errors)
	}

	return nil
}

func (m *UnbindUserPhoneReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// UnbindUserPhoneReqMultiError is an error wrapping multiple validation errors
// returned by UnbindUserPhoneReq.ValidateAll() if the designated constraints
// aren't met.
type UnbindUserPhoneReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UnbindUserPhoneReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UnbindUserPhoneReqMultiError) AllErrors() []error { return m }

// UnbindUserPhoneReqValidationError is the validation error returned by
// UnbindUserPhoneReq.Validate if the designated constraints aren't met.
type UnbindUserPhoneReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UnbindUserPhoneReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UnbindUserPhoneReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UnbindUserPhoneReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UnbindUserPhoneReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UnbindUserPhoneReqValidationError) ErrorName() string {
	return "UnbindUserPhoneReqValidationError"
}

// Error satisfies the builtin error interface
func (e UnbindUserPhoneReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sUnbindUserPhoneReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UnbindUserPhoneReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UnbindUserPhoneReqValidationError{}

var _UnbindUserPhoneReq_Phone_Pattern = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$")

var _UnbindUserPhoneReq_Code_Pattern = regexp.MustCompile("^[0-9]{6}$")

// Validate checks the field values on UnbindUserEmailReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UnbindUserEmailReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UnbindUserEmailReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UnbindUserEmailReqMultiError, or nil if none found.
func (m *UnbindUserEmailReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UnbindUserEmailReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = UnbindUserEmailReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetEmail()) > 50 {
		err := UnbindUserEmailReqValidationError{
			field:  "Email",
			reason: "value length must be at most 50 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UnbindUserEmailReq_Email_Pattern.MatchString(m.GetEmail()) {
		err := UnbindUserEmailReqValidationError{
			field:  "Email",
			reason: "value does not match regex pattern \"\\\\w+([-+.]\\\\w+)*@\\\\w+([-.]\\\\w+)*\\\\.\\\\w+([-.]\\\\w+)*\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UnbindUserEmailReq_Code_Pattern.MatchString(m.GetCode()) {
		err := UnbindUserEmailReqValidationError{
			field:  "Code",
			reason: "value does not match regex pattern \"^[0-9]{6}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return UnbindUserEmailReqMultiError(errors)
	}

	return nil
}

func (m *UnbindUserEmailReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// UnbindUserEmailReqMultiError is an error wrapping multiple validation errors
// returned by UnbindUserEmailReq.ValidateAll() if the designated constraints
// aren't met.
type UnbindUserEmailReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UnbindUserEmailReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UnbindUserEmailReqMultiError) AllErrors() []error { return m }

// UnbindUserEmailReqValidationError is the validation error returned by
// UnbindUserEmailReq.Validate if the designated constraints aren't met.
type UnbindUserEmailReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UnbindUserEmailReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UnbindUserEmailReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UnbindUserEmailReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UnbindUserEmailReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UnbindUserEmailReqValidationError) ErrorName() string {
	return "UnbindUserEmailReqValidationError"
}

// Error satisfies the builtin error interface
func (e UnbindUserEmailReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sUnbindUserEmailReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UnbindUserEmailReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UnbindUserEmailReqValidationError{}

var _UnbindUserEmailReq_Email_Pattern = regexp.MustCompile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*")

var _UnbindUserEmailReq_Code_Pattern = regexp.MustCompile("^[0-9]{6}$")

// Validate checks the field values on GetAccountReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetAccountReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetAccountReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetAccountReqMultiError, or
// nil if none found.
func (m *GetAccountReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetAccountReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetAccountReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetAccountReqMultiError(errors)
	}

	return nil
}

func (m *GetAccountReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetAccountReqMultiError is an error wrapping multiple validation errors
// returned by GetAccountReq.ValidateAll() if the designated constraints
// aren't met.
type GetAccountReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetAccountReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetAccountReqMultiError) AllErrors() []error { return m }

// GetAccountReqValidationError is the validation error returned by
// GetAccountReq.Validate if the designated constraints aren't met.
type GetAccountReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetAccountReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetAccountReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetAccountReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetAccountReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetAccountReqValidationError) ErrorName() string { return "GetAccountReqValidationError" }

// Error satisfies the builtin error interface
func (e GetAccountReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetAccountReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetAccountReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetAccountReqValidationError{}

// Validate checks the field values on GetAccountReply with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetAccountReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetAccountReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetAccountReplyMultiError, or nil if none found.
func (m *GetAccountReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetAccountReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Phone

	// no validation rules for Email

	// no validation rules for Qq

	// no validation rules for Wechat

	// no validation rules for Weibo

	// no validation rules for Github

	// no validation rules for Password

	if len(errors) > 0 {
		return GetAccountReplyMultiError(errors)
	}

	return nil
}

// GetAccountReplyMultiError is an error wrapping multiple validation errors
// returned by GetAccountReply.ValidateAll() if the designated constraints
// aren't met.
type GetAccountReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetAccountReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetAccountReplyMultiError) AllErrors() []error { return m }

// GetAccountReplyValidationError is the validation error returned by
// GetAccountReply.Validate if the designated constraints aren't met.
type GetAccountReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetAccountReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetAccountReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetAccountReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetAccountReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetAccountReplyValidationError) ErrorName() string { return "GetAccountReplyValidationError" }

// Error satisfies the builtin error interface
func (e GetAccountReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetAccountReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetAccountReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetAccountReplyValidationError{}

// Validate checks the field values on GetProfileReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetProfileReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetProfileReqMultiError, or
// nil if none found.
func (m *GetProfileReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetProfileReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetProfileReqMultiError(errors)
	}

	return nil
}

func (m *GetProfileReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetProfileReqMultiError is an error wrapping multiple validation errors
// returned by GetProfileReq.ValidateAll() if the designated constraints
// aren't met.
type GetProfileReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileReqMultiError) AllErrors() []error { return m }

// GetProfileReqValidationError is the validation error returned by
// GetProfileReq.Validate if the designated constraints aren't met.
type GetProfileReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileReqValidationError) ErrorName() string { return "GetProfileReqValidationError" }

// Error satisfies the builtin error interface
func (e GetProfileReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileReqValidationError{}

// Validate checks the field values on GetProfileReply with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetProfileReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetProfileReplyMultiError, or nil if none found.
func (m *GetProfileReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Username

	// no validation rules for Avatar

	// no validation rules for School

	// no validation rules for Company

	// no validation rules for Job

	// no validation rules for Homepage

	// no validation rules for Introduce

	// no validation rules for Created

	if len(errors) > 0 {
		return GetProfileReplyMultiError(errors)
	}

	return nil
}

// GetProfileReplyMultiError is an error wrapping multiple validation errors
// returned by GetProfileReply.ValidateAll() if the designated constraints
// aren't met.
type GetProfileReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileReplyMultiError) AllErrors() []error { return m }

// GetProfileReplyValidationError is the validation error returned by
// GetProfileReply.Validate if the designated constraints aren't met.
type GetProfileReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileReplyValidationError) ErrorName() string { return "GetProfileReplyValidationError" }

// Error satisfies the builtin error interface
func (e GetProfileReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileReplyValidationError{}

// Validate checks the field values on GetProfileListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetProfileListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetProfileListReqMultiError, or nil if none found.
func (m *GetProfileListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return GetProfileListReqMultiError(errors)
	}

	return nil
}

// GetProfileListReqMultiError is an error wrapping multiple validation errors
// returned by GetProfileListReq.ValidateAll() if the designated constraints
// aren't met.
type GetProfileListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileListReqMultiError) AllErrors() []error { return m }

// GetProfileListReqValidationError is the validation error returned by
// GetProfileListReq.Validate if the designated constraints aren't met.
type GetProfileListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileListReqValidationError) ErrorName() string {
	return "GetProfileListReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetProfileListReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileListReqValidationError{}

// Validate checks the field values on GetProfileListReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetProfileListReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileListReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetProfileListReplyMultiError, or nil if none found.
func (m *GetProfileListReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileListReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetProfile() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetProfileListReplyValidationError{
						field:  fmt.Sprintf("Profile[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetProfileListReplyValidationError{
						field:  fmt.Sprintf("Profile[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetProfileListReplyValidationError{
					field:  fmt.Sprintf("Profile[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return GetProfileListReplyMultiError(errors)
	}

	return nil
}

// GetProfileListReplyMultiError is an error wrapping multiple validation
// errors returned by GetProfileListReply.ValidateAll() if the designated
// constraints aren't met.
type GetProfileListReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileListReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileListReplyMultiError) AllErrors() []error { return m }

// GetProfileListReplyValidationError is the validation error returned by
// GetProfileListReply.Validate if the designated constraints aren't met.
type GetProfileListReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileListReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileListReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileListReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileListReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileListReplyValidationError) ErrorName() string {
	return "GetProfileListReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetProfileListReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileListReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileListReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileListReplyValidationError{}

// Validate checks the field values on GetProfileUpdateReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetProfileUpdateReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileUpdateReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetProfileUpdateReqMultiError, or nil if none found.
func (m *GetProfileUpdateReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileUpdateReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetProfileUpdateReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetProfileUpdateReqMultiError(errors)
	}

	return nil
}

func (m *GetProfileUpdateReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetProfileUpdateReqMultiError is an error wrapping multiple validation
// errors returned by GetProfileUpdateReq.ValidateAll() if the designated
// constraints aren't met.
type GetProfileUpdateReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileUpdateReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileUpdateReqMultiError) AllErrors() []error { return m }

// GetProfileUpdateReqValidationError is the validation error returned by
// GetProfileUpdateReq.Validate if the designated constraints aren't met.
type GetProfileUpdateReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileUpdateReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileUpdateReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileUpdateReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileUpdateReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileUpdateReqValidationError) ErrorName() string {
	return "GetProfileUpdateReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetProfileUpdateReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileUpdateReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileUpdateReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileUpdateReqValidationError{}

// Validate checks the field values on GetProfileUpdateReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetProfileUpdateReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileUpdateReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetProfileUpdateReplyMultiError, or nil if none found.
func (m *GetProfileUpdateReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileUpdateReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Username

	// no validation rules for Avatar

	// no validation rules for School

	// no validation rules for Company

	// no validation rules for Job

	// no validation rules for Homepage

	// no validation rules for Introduce

	// no validation rules for Status

	if len(errors) > 0 {
		return GetProfileUpdateReplyMultiError(errors)
	}

	return nil
}

// GetProfileUpdateReplyMultiError is an error wrapping multiple validation
// errors returned by GetProfileUpdateReply.ValidateAll() if the designated
// constraints aren't met.
type GetProfileUpdateReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileUpdateReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileUpdateReplyMultiError) AllErrors() []error { return m }

// GetProfileUpdateReplyValidationError is the validation error returned by
// GetProfileUpdateReply.Validate if the designated constraints aren't met.
type GetProfileUpdateReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileUpdateReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileUpdateReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileUpdateReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileUpdateReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileUpdateReplyValidationError) ErrorName() string {
	return "GetProfileUpdateReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetProfileUpdateReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileUpdateReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileUpdateReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileUpdateReplyValidationError{}

// Validate checks the field values on GetUserFollowReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetUserFollowReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserFollowReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserFollowReqMultiError, or nil if none found.
func (m *GetUserFollowReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserFollowReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetUserFollowReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if err := m._validateUuid(m.GetUserUuid()); err != nil {
		err = GetUserFollowReqValidationError{
			field:  "UserUuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetUserFollowReqMultiError(errors)
	}

	return nil
}

func (m *GetUserFollowReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetUserFollowReqMultiError is an error wrapping multiple validation errors
// returned by GetUserFollowReq.ValidateAll() if the designated constraints
// aren't met.
type GetUserFollowReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserFollowReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserFollowReqMultiError) AllErrors() []error { return m }

// GetUserFollowReqValidationError is the validation error returned by
// GetUserFollowReq.Validate if the designated constraints aren't met.
type GetUserFollowReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserFollowReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserFollowReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserFollowReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserFollowReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserFollowReqValidationError) ErrorName() string { return "GetUserFollowReqValidationError" }

// Error satisfies the builtin error interface
func (e GetUserFollowReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserFollowReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserFollowReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserFollowReqValidationError{}

// Validate checks the field values on GetUserFollowReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetUserFollowReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserFollowReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserFollowReplyMultiError, or nil if none found.
func (m *GetUserFollowReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserFollowReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Follow

	if len(errors) > 0 {
		return GetUserFollowReplyMultiError(errors)
	}

	return nil
}

// GetUserFollowReplyMultiError is an error wrapping multiple validation errors
// returned by GetUserFollowReply.ValidateAll() if the designated constraints
// aren't met.
type GetUserFollowReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserFollowReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserFollowReplyMultiError) AllErrors() []error { return m }

// GetUserFollowReplyValidationError is the validation error returned by
// GetUserFollowReply.Validate if the designated constraints aren't met.
type GetUserFollowReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserFollowReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserFollowReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserFollowReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserFollowReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserFollowReplyValidationError) ErrorName() string {
	return "GetUserFollowReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetUserFollowReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserFollowReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserFollowReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserFollowReplyValidationError{}

// Validate checks the field values on GetFollowListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetFollowListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowListReqMultiError, or nil if none found.
func (m *GetFollowListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Page

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetFollowListReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetFollowListReqMultiError(errors)
	}

	return nil
}

func (m *GetFollowListReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetFollowListReqMultiError is an error wrapping multiple validation errors
// returned by GetFollowListReq.ValidateAll() if the designated constraints
// aren't met.
type GetFollowListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowListReqMultiError) AllErrors() []error { return m }

// GetFollowListReqValidationError is the validation error returned by
// GetFollowListReq.Validate if the designated constraints aren't met.
type GetFollowListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowListReqValidationError) ErrorName() string { return "GetFollowListReqValidationError" }

// Error satisfies the builtin error interface
func (e GetFollowListReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowListReqValidationError{}

// Validate checks the field values on GetFollowListReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowListReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowListReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowListReplyMultiError, or nil if none found.
func (m *GetFollowListReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowListReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetFollow() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetFollowListReplyValidationError{
						field:  fmt.Sprintf("Follow[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetFollowListReplyValidationError{
						field:  fmt.Sprintf("Follow[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetFollowListReplyValidationError{
					field:  fmt.Sprintf("Follow[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return GetFollowListReplyMultiError(errors)
	}

	return nil
}

// GetFollowListReplyMultiError is an error wrapping multiple validation errors
// returned by GetFollowListReply.ValidateAll() if the designated constraints
// aren't met.
type GetFollowListReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowListReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowListReplyMultiError) AllErrors() []error { return m }

// GetFollowListReplyValidationError is the validation error returned by
// GetFollowListReply.Validate if the designated constraints aren't met.
type GetFollowListReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowListReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowListReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowListReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowListReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowListReplyValidationError) ErrorName() string {
	return "GetFollowListReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowListReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowListReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowListReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowListReplyValidationError{}

// Validate checks the field values on GetFollowListCountReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowListCountReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowListCountReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowListCountReqMultiError, or nil if none found.
func (m *GetFollowListCountReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowListCountReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetFollowListCountReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetFollowListCountReqMultiError(errors)
	}

	return nil
}

func (m *GetFollowListCountReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetFollowListCountReqMultiError is an error wrapping multiple validation
// errors returned by GetFollowListCountReq.ValidateAll() if the designated
// constraints aren't met.
type GetFollowListCountReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowListCountReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowListCountReqMultiError) AllErrors() []error { return m }

// GetFollowListCountReqValidationError is the validation error returned by
// GetFollowListCountReq.Validate if the designated constraints aren't met.
type GetFollowListCountReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowListCountReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowListCountReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowListCountReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowListCountReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowListCountReqValidationError) ErrorName() string {
	return "GetFollowListCountReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowListCountReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowListCountReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowListCountReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowListCountReqValidationError{}

// Validate checks the field values on GetFollowListCountReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowListCountReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowListCountReply with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowListCountReplyMultiError, or nil if none found.
func (m *GetFollowListCountReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowListCountReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Count

	if len(errors) > 0 {
		return GetFollowListCountReplyMultiError(errors)
	}

	return nil
}

// GetFollowListCountReplyMultiError is an error wrapping multiple validation
// errors returned by GetFollowListCountReply.ValidateAll() if the designated
// constraints aren't met.
type GetFollowListCountReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowListCountReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowListCountReplyMultiError) AllErrors() []error { return m }

// GetFollowListCountReplyValidationError is the validation error returned by
// GetFollowListCountReply.Validate if the designated constraints aren't met.
type GetFollowListCountReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowListCountReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowListCountReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowListCountReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowListCountReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowListCountReplyValidationError) ErrorName() string {
	return "GetFollowListCountReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowListCountReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowListCountReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowListCountReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowListCountReplyValidationError{}

// Validate checks the field values on GetFollowedListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowedListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowedListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowedListReqMultiError, or nil if none found.
func (m *GetFollowedListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowedListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Page

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetFollowedListReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetFollowedListReqMultiError(errors)
	}

	return nil
}

func (m *GetFollowedListReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetFollowedListReqMultiError is an error wrapping multiple validation errors
// returned by GetFollowedListReq.ValidateAll() if the designated constraints
// aren't met.
type GetFollowedListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowedListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowedListReqMultiError) AllErrors() []error { return m }

// GetFollowedListReqValidationError is the validation error returned by
// GetFollowedListReq.Validate if the designated constraints aren't met.
type GetFollowedListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowedListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowedListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowedListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowedListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowedListReqValidationError) ErrorName() string {
	return "GetFollowedListReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowedListReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowedListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowedListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowedListReqValidationError{}

// Validate checks the field values on GetFollowedListReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowedListReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowedListReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowedListReplyMultiError, or nil if none found.
func (m *GetFollowedListReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowedListReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetFollow() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetFollowedListReplyValidationError{
						field:  fmt.Sprintf("Follow[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetFollowedListReplyValidationError{
						field:  fmt.Sprintf("Follow[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetFollowedListReplyValidationError{
					field:  fmt.Sprintf("Follow[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return GetFollowedListReplyMultiError(errors)
	}

	return nil
}

// GetFollowedListReplyMultiError is an error wrapping multiple validation
// errors returned by GetFollowedListReply.ValidateAll() if the designated
// constraints aren't met.
type GetFollowedListReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowedListReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowedListReplyMultiError) AllErrors() []error { return m }

// GetFollowedListReplyValidationError is the validation error returned by
// GetFollowedListReply.Validate if the designated constraints aren't met.
type GetFollowedListReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowedListReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowedListReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowedListReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowedListReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowedListReplyValidationError) ErrorName() string {
	return "GetFollowedListReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowedListReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowedListReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowedListReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowedListReplyValidationError{}

// Validate checks the field values on GetFollowedListCountReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowedListCountReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowedListCountReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowedListCountReqMultiError, or nil if none found.
func (m *GetFollowedListCountReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowedListCountReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetFollowedListCountReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetFollowedListCountReqMultiError(errors)
	}

	return nil
}

func (m *GetFollowedListCountReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetFollowedListCountReqMultiError is an error wrapping multiple validation
// errors returned by GetFollowedListCountReq.ValidateAll() if the designated
// constraints aren't met.
type GetFollowedListCountReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowedListCountReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowedListCountReqMultiError) AllErrors() []error { return m }

// GetFollowedListCountReqValidationError is the validation error returned by
// GetFollowedListCountReq.Validate if the designated constraints aren't met.
type GetFollowedListCountReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowedListCountReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowedListCountReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowedListCountReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowedListCountReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowedListCountReqValidationError) ErrorName() string {
	return "GetFollowedListCountReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowedListCountReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowedListCountReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowedListCountReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowedListCountReqValidationError{}

// Validate checks the field values on GetFollowedListCountReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowedListCountReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowedListCountReply with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowedListCountReplyMultiError, or nil if none found.
func (m *GetFollowedListCountReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowedListCountReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Count

	if len(errors) > 0 {
		return GetFollowedListCountReplyMultiError(errors)
	}

	return nil
}

// GetFollowedListCountReplyMultiError is an error wrapping multiple validation
// errors returned by GetFollowedListCountReply.ValidateAll() if the
// designated constraints aren't met.
type GetFollowedListCountReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowedListCountReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowedListCountReplyMultiError) AllErrors() []error { return m }

// GetFollowedListCountReplyValidationError is the validation error returned by
// GetFollowedListCountReply.Validate if the designated constraints aren't met.
type GetFollowedListCountReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowedListCountReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowedListCountReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowedListCountReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowedListCountReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowedListCountReplyValidationError) ErrorName() string {
	return "GetFollowedListCountReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowedListCountReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowedListCountReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowedListCountReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowedListCountReplyValidationError{}

// Validate checks the field values on GetUserFollowsReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetUserFollowsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserFollowsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserFollowsReqMultiError, or nil if none found.
func (m *GetUserFollowsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserFollowsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetUserFollowsReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetUserFollowsReqMultiError(errors)
	}

	return nil
}

func (m *GetUserFollowsReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetUserFollowsReqMultiError is an error wrapping multiple validation errors
// returned by GetUserFollowsReq.ValidateAll() if the designated constraints
// aren't met.
type GetUserFollowsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserFollowsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserFollowsReqMultiError) AllErrors() []error { return m }

// GetUserFollowsReqValidationError is the validation error returned by
// GetUserFollowsReq.Validate if the designated constraints aren't met.
type GetUserFollowsReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserFollowsReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserFollowsReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserFollowsReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserFollowsReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserFollowsReqValidationError) ErrorName() string {
	return "GetUserFollowsReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetUserFollowsReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserFollowsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserFollowsReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserFollowsReqValidationError{}

// Validate checks the field values on GetUserFollowsReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetUserFollowsReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserFollowsReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserFollowsReplyMultiError, or nil if none found.
func (m *GetUserFollowsReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserFollowsReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Follows

	if len(errors) > 0 {
		return GetUserFollowsReplyMultiError(errors)
	}

	return nil
}

// GetUserFollowsReplyMultiError is an error wrapping multiple validation
// errors returned by GetUserFollowsReply.ValidateAll() if the designated
// constraints aren't met.
type GetUserFollowsReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserFollowsReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserFollowsReplyMultiError) AllErrors() []error { return m }

// GetUserFollowsReplyValidationError is the validation error returned by
// GetUserFollowsReply.Validate if the designated constraints aren't met.
type GetUserFollowsReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserFollowsReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserFollowsReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserFollowsReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserFollowsReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserFollowsReplyValidationError) ErrorName() string {
	return "GetUserFollowsReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetUserFollowsReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserFollowsReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserFollowsReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserFollowsReplyValidationError{}

// Validate checks the field values on GetUserSearchReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetUserSearchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserSearchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserSearchReqMultiError, or nil if none found.
func (m *GetUserSearchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserSearchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Page

	// no validation rules for Search

	if len(errors) > 0 {
		return GetUserSearchReqMultiError(errors)
	}

	return nil
}

// GetUserSearchReqMultiError is an error wrapping multiple validation errors
// returned by GetUserSearchReq.ValidateAll() if the designated constraints
// aren't met.
type GetUserSearchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserSearchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserSearchReqMultiError) AllErrors() []error { return m }

// GetUserSearchReqValidationError is the validation error returned by
// GetUserSearchReq.Validate if the designated constraints aren't met.
type GetUserSearchReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserSearchReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserSearchReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserSearchReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserSearchReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserSearchReqValidationError) ErrorName() string { return "GetUserSearchReqValidationError" }

// Error satisfies the builtin error interface
func (e GetUserSearchReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserSearchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserSearchReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserSearchReqValidationError{}

// Validate checks the field values on GetUserSearchReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetUserSearchReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserSearchReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserSearchReplyMultiError, or nil if none found.
func (m *GetUserSearchReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserSearchReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetList() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetUserSearchReplyValidationError{
						field:  fmt.Sprintf("List[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetUserSearchReplyValidationError{
						field:  fmt.Sprintf("List[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetUserSearchReplyValidationError{
					field:  fmt.Sprintf("List[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Total

	if len(errors) > 0 {
		return GetUserSearchReplyMultiError(errors)
	}

	return nil
}

// GetUserSearchReplyMultiError is an error wrapping multiple validation errors
// returned by GetUserSearchReply.ValidateAll() if the designated constraints
// aren't met.
type GetUserSearchReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserSearchReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserSearchReplyMultiError) AllErrors() []error { return m }

// GetUserSearchReplyValidationError is the validation error returned by
// GetUserSearchReply.Validate if the designated constraints aren't met.
type GetUserSearchReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserSearchReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserSearchReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserSearchReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserSearchReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserSearchReplyValidationError) ErrorName() string {
	return "GetUserSearchReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetUserSearchReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserSearchReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserSearchReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserSearchReplyValidationError{}

// Validate checks the field values on GetAvatarReviewReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetAvatarReviewReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetAvatarReviewReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetAvatarReviewReqMultiError, or nil if none found.
func (m *GetAvatarReviewReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetAvatarReviewReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Page

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetAvatarReviewReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetAvatarReviewReqMultiError(errors)
	}

	return nil
}

func (m *GetAvatarReviewReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetAvatarReviewReqMultiError is an error wrapping multiple validation errors
// returned by GetAvatarReviewReq.ValidateAll() if the designated constraints
// aren't met.
type GetAvatarReviewReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetAvatarReviewReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetAvatarReviewReqMultiError) AllErrors() []error { return m }

// GetAvatarReviewReqValidationError is the validation error returned by
// GetAvatarReviewReq.Validate if the designated constraints aren't met.
type GetAvatarReviewReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetAvatarReviewReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetAvatarReviewReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetAvatarReviewReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetAvatarReviewReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetAvatarReviewReqValidationError) ErrorName() string {
	return "GetAvatarReviewReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetAvatarReviewReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetAvatarReviewReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetAvatarReviewReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetAvatarReviewReqValidationError{}

// Validate checks the field values on GetAvatarReviewReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetAvatarReviewReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetAvatarReviewReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetAvatarReviewReplyMultiError, or nil if none found.
func (m *GetAvatarReviewReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetAvatarReviewReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetReview() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetAvatarReviewReplyValidationError{
						field:  fmt.Sprintf("Review[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetAvatarReviewReplyValidationError{
						field:  fmt.Sprintf("Review[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetAvatarReviewReplyValidationError{
					field:  fmt.Sprintf("Review[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return GetAvatarReviewReplyMultiError(errors)
	}

	return nil
}

// GetAvatarReviewReplyMultiError is an error wrapping multiple validation
// errors returned by GetAvatarReviewReply.ValidateAll() if the designated
// constraints aren't met.
type GetAvatarReviewReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetAvatarReviewReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetAvatarReviewReplyMultiError) AllErrors() []error { return m }

// GetAvatarReviewReplyValidationError is the validation error returned by
// GetAvatarReviewReply.Validate if the designated constraints aren't met.
type GetAvatarReviewReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetAvatarReviewReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetAvatarReviewReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetAvatarReviewReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetAvatarReviewReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetAvatarReviewReplyValidationError) ErrorName() string {
	return "GetAvatarReviewReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetAvatarReviewReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetAvatarReviewReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetAvatarReviewReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetAvatarReviewReplyValidationError{}

// Validate checks the field values on GetCoverReviewReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetCoverReviewReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCoverReviewReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetCoverReviewReqMultiError, or nil if none found.
func (m *GetCoverReviewReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCoverReviewReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Page

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = GetCoverReviewReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return GetCoverReviewReqMultiError(errors)
	}

	return nil
}

func (m *GetCoverReviewReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// GetCoverReviewReqMultiError is an error wrapping multiple validation errors
// returned by GetCoverReviewReq.ValidateAll() if the designated constraints
// aren't met.
type GetCoverReviewReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCoverReviewReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCoverReviewReqMultiError) AllErrors() []error { return m }

// GetCoverReviewReqValidationError is the validation error returned by
// GetCoverReviewReq.Validate if the designated constraints aren't met.
type GetCoverReviewReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCoverReviewReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCoverReviewReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCoverReviewReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCoverReviewReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCoverReviewReqValidationError) ErrorName() string {
	return "GetCoverReviewReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetCoverReviewReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetCoverReviewReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCoverReviewReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCoverReviewReqValidationError{}

// Validate checks the field values on GetCoverReviewReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCoverReviewReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCoverReviewReply with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetCoverReviewReplyMultiError, or nil if none found.
func (m *GetCoverReviewReply) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCoverReviewReply) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetReview() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetCoverReviewReplyValidationError{
						field:  fmt.Sprintf("Review[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetCoverReviewReplyValidationError{
						field:  fmt.Sprintf("Review[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetCoverReviewReplyValidationError{
					field:  fmt.Sprintf("Review[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return GetCoverReviewReplyMultiError(errors)
	}

	return nil
}

// GetCoverReviewReplyMultiError is an error wrapping multiple validation
// errors returned by GetCoverReviewReply.ValidateAll() if the designated
// constraints aren't met.
type GetCoverReviewReplyMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCoverReviewReplyMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCoverReviewReplyMultiError) AllErrors() []error { return m }

// GetCoverReviewReplyValidationError is the validation error returned by
// GetCoverReviewReply.Validate if the designated constraints aren't met.
type GetCoverReviewReplyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCoverReviewReplyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCoverReviewReplyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCoverReviewReplyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCoverReviewReplyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCoverReviewReplyValidationError) ErrorName() string {
	return "GetCoverReviewReplyValidationError"
}

// Error satisfies the builtin error interface
func (e GetCoverReviewReplyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetCoverReviewReply.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCoverReviewReplyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCoverReviewReplyValidationError{}

// Validate checks the field values on SetProfileUpdateReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *SetProfileUpdateReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetProfileUpdateReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// SetProfileUpdateReqMultiError, or nil if none found.
func (m *SetProfileUpdateReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetProfileUpdateReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SetProfileUpdateReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetUsername()); l < 1 || l > 20 {
		err := SetProfileUpdateReqValidationError{
			field:  "Username",
			reason: "value length must be between 1 and 20 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetSchool()); l < 0 || l > 50 {
		err := SetProfileUpdateReqValidationError{
			field:  "School",
			reason: "value length must be between 0 and 50 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetCompany()); l < 0 || l > 50 {
		err := SetProfileUpdateReqValidationError{
			field:  "Company",
			reason: "value length must be between 0 and 50 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetJob()); l < 0 || l > 50 {
		err := SetProfileUpdateReqValidationError{
			field:  "Job",
			reason: "value length must be between 0 and 50 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetHomepage()); l < 0 || l > 100 {
		err := SetProfileUpdateReqValidationError{
			field:  "Homepage",
			reason: "value length must be between 0 and 100 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetIntroduce()); l < 0 || l > 100 {
		err := SetProfileUpdateReqValidationError{
			field:  "Introduce",
			reason: "value length must be between 0 and 100 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return SetProfileUpdateReqMultiError(errors)
	}

	return nil
}

func (m *SetProfileUpdateReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// SetProfileUpdateReqMultiError is an error wrapping multiple validation
// errors returned by SetProfileUpdateReq.ValidateAll() if the designated
// constraints aren't met.
type SetProfileUpdateReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetProfileUpdateReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetProfileUpdateReqMultiError) AllErrors() []error { return m }

// SetProfileUpdateReqValidationError is the validation error returned by
// SetProfileUpdateReq.Validate if the designated constraints aren't met.
type SetProfileUpdateReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SetProfileUpdateReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SetProfileUpdateReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SetProfileUpdateReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SetProfileUpdateReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SetProfileUpdateReqValidationError) ErrorName() string {
	return "SetProfileUpdateReqValidationError"
}

// Error satisfies the builtin error interface
func (e SetProfileUpdateReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSetProfileUpdateReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetProfileUpdateReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SetProfileUpdateReqValidationError{}

// Validate checks the field values on ProfileReviewPassReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ProfileReviewPassReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ProfileReviewPassReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ProfileReviewPassReqMultiError, or nil if none found.
func (m *ProfileReviewPassReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ProfileReviewPassReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ProfileReviewPassReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetUpdate()) > 20 {
		err := ProfileReviewPassReqValidationError{
			field:  "Update",
			reason: "value length must be at most 20 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return ProfileReviewPassReqMultiError(errors)
	}

	return nil
}

func (m *ProfileReviewPassReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// ProfileReviewPassReqMultiError is an error wrapping multiple validation
// errors returned by ProfileReviewPassReq.ValidateAll() if the designated
// constraints aren't met.
type ProfileReviewPassReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ProfileReviewPassReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ProfileReviewPassReqMultiError) AllErrors() []error { return m }

// ProfileReviewPassReqValidationError is the validation error returned by
// ProfileReviewPassReq.Validate if the designated constraints aren't met.
type ProfileReviewPassReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ProfileReviewPassReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ProfileReviewPassReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ProfileReviewPassReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ProfileReviewPassReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ProfileReviewPassReqValidationError) ErrorName() string {
	return "ProfileReviewPassReqValidationError"
}

// Error satisfies the builtin error interface
func (e ProfileReviewPassReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sProfileReviewPassReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ProfileReviewPassReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ProfileReviewPassReqValidationError{}

// Validate checks the field values on ProfileReviewNotPassReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ProfileReviewNotPassReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ProfileReviewNotPassReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ProfileReviewNotPassReqMultiError, or nil if none found.
func (m *ProfileReviewNotPassReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ProfileReviewNotPassReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ProfileReviewNotPassReqValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return ProfileReviewNotPassReqMultiError(errors)
	}

	return nil
}

func (m *ProfileReviewNotPassReq) _validateUuid(uuid string) error {
	if matched := _user_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

// ProfileReviewNotPassReqMultiError is an error wrapping multiple validation
// errors returned by ProfileReviewNotPassReq.ValidateAll() if the designated
// constraints aren't met.
type ProfileReviewNotPassReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ProfileReviewNotPassReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ProfileReviewNotPassReqMultiError) AllErrors() []error { return m }

// ProfileReviewNotPassReqValidationError is the validation error returned by
// ProfileReviewNotPassReq.Validate if the designated constraints aren't met.
type ProfileReviewNotPassReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ProfileReviewNotPassReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ProfileReviewNotPassReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ProfileReviewNotPassReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ProfileReviewNotPassReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ProfileReviewNotPassReqValidationError) ErrorName() string {
	return "ProfileReviewNotPassReqValidationError"
}

// Error satisfies the builtin error interface
func (e ProfileReviewNotPassReqValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sProfileReviewNotPassReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ProfileReviewNotPassReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ProfileReviewNotPassReqValidationError{}

// Validate checks the field values on GetProfileListReply_Profile with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetProfileListReply_Profile) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetProfileListReply_Profile with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetProfileListReply_ProfileMultiError, or nil if none found.
func (m *GetProfileListReply_Profile) ValidateAll() error {
	return m.validate(true)
}

func (m *GetProfileListReply_Profile) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Username

	// no validation rules for Introduce

	if len(errors) > 0 {
		return GetProfileListReply_ProfileMultiError(errors)
	}

	return nil
}

// GetProfileListReply_ProfileMultiError is an error wrapping multiple
// validation errors returned by GetProfileListReply_Profile.ValidateAll() if
// the designated constraints aren't met.
type GetProfileListReply_ProfileMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetProfileListReply_ProfileMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetProfileListReply_ProfileMultiError) AllErrors() []error { return m }

// GetProfileListReply_ProfileValidationError is the validation error returned
// by GetProfileListReply_Profile.Validate if the designated constraints
// aren't met.
type GetProfileListReply_ProfileValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetProfileListReply_ProfileValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetProfileListReply_ProfileValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetProfileListReply_ProfileValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetProfileListReply_ProfileValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetProfileListReply_ProfileValidationError) ErrorName() string {
	return "GetProfileListReply_ProfileValidationError"
}

// Error satisfies the builtin error interface
func (e GetProfileListReply_ProfileValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetProfileListReply_Profile.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetProfileListReply_ProfileValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetProfileListReply_ProfileValidationError{}

// Validate checks the field values on GetFollowListReply_Follow with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowListReply_Follow) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowListReply_Follow with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowListReply_FollowMultiError, or nil if none found.
func (m *GetFollowListReply_Follow) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowListReply_Follow) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetFollowListReply_FollowMultiError(errors)
	}

	return nil
}

// GetFollowListReply_FollowMultiError is an error wrapping multiple validation
// errors returned by GetFollowListReply_Follow.ValidateAll() if the
// designated constraints aren't met.
type GetFollowListReply_FollowMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowListReply_FollowMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowListReply_FollowMultiError) AllErrors() []error { return m }

// GetFollowListReply_FollowValidationError is the validation error returned by
// GetFollowListReply_Follow.Validate if the designated constraints aren't met.
type GetFollowListReply_FollowValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowListReply_FollowValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowListReply_FollowValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowListReply_FollowValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowListReply_FollowValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowListReply_FollowValidationError) ErrorName() string {
	return "GetFollowListReply_FollowValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowListReply_FollowValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowListReply_Follow.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowListReply_FollowValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowListReply_FollowValidationError{}

// Validate checks the field values on GetFollowedListReply_Follow with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetFollowedListReply_Follow) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetFollowedListReply_Follow with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetFollowedListReply_FollowMultiError, or nil if none found.
func (m *GetFollowedListReply_Follow) ValidateAll() error {
	return m.validate(true)
}

func (m *GetFollowedListReply_Follow) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetFollowedListReply_FollowMultiError(errors)
	}

	return nil
}

// GetFollowedListReply_FollowMultiError is an error wrapping multiple
// validation errors returned by GetFollowedListReply_Follow.ValidateAll() if
// the designated constraints aren't met.
type GetFollowedListReply_FollowMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetFollowedListReply_FollowMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetFollowedListReply_FollowMultiError) AllErrors() []error { return m }

// GetFollowedListReply_FollowValidationError is the validation error returned
// by GetFollowedListReply_Follow.Validate if the designated constraints
// aren't met.
type GetFollowedListReply_FollowValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetFollowedListReply_FollowValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetFollowedListReply_FollowValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetFollowedListReply_FollowValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetFollowedListReply_FollowValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetFollowedListReply_FollowValidationError) ErrorName() string {
	return "GetFollowedListReply_FollowValidationError"
}

// Error satisfies the builtin error interface
func (e GetFollowedListReply_FollowValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetFollowedListReply_Follow.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetFollowedListReply_FollowValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetFollowedListReply_FollowValidationError{}

// Validate checks the field values on GetUserSearchReply_List with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetUserSearchReply_List) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetUserSearchReply_List with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetUserSearchReply_ListMultiError, or nil if none found.
func (m *GetUserSearchReply_List) ValidateAll() error {
	return m.validate(true)
}

func (m *GetUserSearchReply_List) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Username

	// no validation rules for Introduce

	if len(errors) > 0 {
		return GetUserSearchReply_ListMultiError(errors)
	}

	return nil
}

// GetUserSearchReply_ListMultiError is an error wrapping multiple validation
// errors returned by GetUserSearchReply_List.ValidateAll() if the designated
// constraints aren't met.
type GetUserSearchReply_ListMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetUserSearchReply_ListMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetUserSearchReply_ListMultiError) AllErrors() []error { return m }

// GetUserSearchReply_ListValidationError is the validation error returned by
// GetUserSearchReply_List.Validate if the designated constraints aren't met.
type GetUserSearchReply_ListValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetUserSearchReply_ListValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetUserSearchReply_ListValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetUserSearchReply_ListValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetUserSearchReply_ListValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetUserSearchReply_ListValidationError) ErrorName() string {
	return "GetUserSearchReply_ListValidationError"
}

// Error satisfies the builtin error interface
func (e GetUserSearchReply_ListValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetUserSearchReply_List.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetUserSearchReply_ListValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetUserSearchReply_ListValidationError{}

// Validate checks the field values on GetAvatarReviewReply_Review with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetAvatarReviewReply_Review) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetAvatarReviewReply_Review with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetAvatarReviewReply_ReviewMultiError, or nil if none found.
func (m *GetAvatarReviewReply_Review) ValidateAll() error {
	return m.validate(true)
}

func (m *GetAvatarReviewReply_Review) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Id

	// no validation rules for Uuid

	// no validation rules for CreateAt

	// no validation rules for JobId

	// no validation rules for Url

	// no validation rules for Label

	// no validation rules for Result

	// no validation rules for Score

	// no validation rules for Category

	// no validation rules for SubLabel

	if len(errors) > 0 {
		return GetAvatarReviewReply_ReviewMultiError(errors)
	}

	return nil
}

// GetAvatarReviewReply_ReviewMultiError is an error wrapping multiple
// validation errors returned by GetAvatarReviewReply_Review.ValidateAll() if
// the designated constraints aren't met.
type GetAvatarReviewReply_ReviewMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetAvatarReviewReply_ReviewMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetAvatarReviewReply_ReviewMultiError) AllErrors() []error { return m }

// GetAvatarReviewReply_ReviewValidationError is the validation error returned
// by GetAvatarReviewReply_Review.Validate if the designated constraints
// aren't met.
type GetAvatarReviewReply_ReviewValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetAvatarReviewReply_ReviewValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetAvatarReviewReply_ReviewValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetAvatarReviewReply_ReviewValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetAvatarReviewReply_ReviewValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetAvatarReviewReply_ReviewValidationError) ErrorName() string {
	return "GetAvatarReviewReply_ReviewValidationError"
}

// Error satisfies the builtin error interface
func (e GetAvatarReviewReply_ReviewValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetAvatarReviewReply_Review.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetAvatarReviewReply_ReviewValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetAvatarReviewReply_ReviewValidationError{}

// Validate checks the field values on GetCoverReviewReply_Review with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCoverReviewReply_Review) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCoverReviewReply_Review with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetCoverReviewReply_ReviewMultiError, or nil if none found.
func (m *GetCoverReviewReply_Review) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCoverReviewReply_Review) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Id

	// no validation rules for Uuid

	// no validation rules for CreateAt

	// no validation rules for JobId

	// no validation rules for Url

	// no validation rules for Label

	// no validation rules for Result

	// no validation rules for Score

	// no validation rules for Category

	// no validation rules for SubLabel

	if len(errors) > 0 {
		return GetCoverReviewReply_ReviewMultiError(errors)
	}

	return nil
}

// GetCoverReviewReply_ReviewMultiError is an error wrapping multiple
// validation errors returned by GetCoverReviewReply_Review.ValidateAll() if
// the designated constraints aren't met.
type GetCoverReviewReply_ReviewMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCoverReviewReply_ReviewMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCoverReviewReply_ReviewMultiError) AllErrors() []error { return m }

// GetCoverReviewReply_ReviewValidationError is the validation error returned
// by GetCoverReviewReply_Review.Validate if the designated constraints aren't met.
type GetCoverReviewReply_ReviewValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCoverReviewReply_ReviewValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCoverReviewReply_ReviewValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCoverReviewReply_ReviewValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCoverReviewReply_ReviewValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCoverReviewReply_ReviewValidationError) ErrorName() string {
	return "GetCoverReviewReply_ReviewValidationError"
}

// Error satisfies the builtin error interface
func (e GetCoverReviewReply_ReviewValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sGetCoverReviewReply_Review.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCoverReviewReply_ReviewValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCoverReviewReply_ReviewValidationError{}