user.pb.validate.go

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

package proto_build

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
)

// Validate checks the field values on User 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 *User) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on User 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 UserMultiError, or nil if none found.
func (m *User) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Nickname

	// no validation rules for Gender

	// no validation rules for AvatarUrl

	// no validation rules for Extra

	if all {
		switch v := interface{}(m.GetCreatedAt()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UserValidationError{
					field:  "CreatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UserValidationError{
					field:  "CreatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UserValidationError{
				field:  "CreatedAt",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetUpdatedAt()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UserValidationError{
					field:  "UpdatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UserValidationError{
					field:  "UpdatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetUpdatedAt()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UserValidationError{
				field:  "UpdatedAt",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetDeletedAt()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UserValidationError{
					field:  "DeletedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UserValidationError{
					field:  "DeletedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetDeletedAt()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UserValidationError{
				field:  "DeletedAt",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserMultiError) 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 UserMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserValidationError) 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 %sUser.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserValidationError{}

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

// Validate checks the field values on UserCreateRequest 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 *UserCreateRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserCreateRequest 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
// UserCreateRequestMultiError, or nil if none found.
func (m *UserCreateRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if !_UserCreateRequest_Nickname_Pattern.MatchString(m.GetNickname()) {
		err := UserCreateRequestValidationError{
			field:  "Nickname",
			reason: "value does not match regex pattern \".{2,30}\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if _, ok := Gender_name[int32(m.GetGender())]; !ok {
		err := UserCreateRequestValidationError{
			field:  "Gender",
			reason: "value must be one of the defined enum values",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if uri, err := url.Parse(m.GetAvatarUrl()); err != nil {
		err = UserCreateRequestValidationError{
			field:  "AvatarUrl",
			reason: "value must be a valid URI",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	} else if !uri.IsAbs() {
		err := UserCreateRequestValidationError{
			field:  "AvatarUrl",
			reason: "value must be absolute",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UserCreateRequest_AvatarUrl_Pattern.MatchString(m.GetAvatarUrl()) {
		err := UserCreateRequestValidationError{
			field:  "AvatarUrl",
			reason: "value does not match regex pattern \"(jpg|jpeg|png)$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UserCreateRequest_Password_Pattern.MatchString(m.GetPassword()) {
		err := UserCreateRequestValidationError{
			field:  "Password",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9]{1,17}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UserCreateRequest_PasswordRpt_Pattern.MatchString(m.GetPasswordRpt()) {
		err := UserCreateRequestValidationError{
			field:  "PasswordRpt",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9]{1,17}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserCreateRequestMultiError) 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 UserCreateRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserCreateRequestValidationError) 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 %sUserCreateRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserCreateRequestValidationError{}

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

var _UserCreateRequest_Nickname_Pattern = regexp.MustCompile(".{2,30}")

var _UserCreateRequest_AvatarUrl_Pattern = regexp.MustCompile("(jpg|jpeg|png)$")

var _UserCreateRequest_Password_Pattern = regexp.MustCompile("^[a-z][a-z0-9]{1,17}$")

var _UserCreateRequest_PasswordRpt_Pattern = regexp.MustCompile("^[a-z][a-z0-9]{1,17}$")

// Validate checks the field values on UserCreateResponse 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 *UserCreateResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserCreateResponse 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
// UserCreateResponseMultiError, or nil if none found.
func (m *UserCreateResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if all {
		switch v := interface{}(m.GetUser()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UserCreateResponseValidationError{
					field:  "User",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UserCreateResponseValidationError{
					field:  "User",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetUser()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UserCreateResponseValidationError{
				field:  "User",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserCreateResponseMultiError) 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 UserCreateResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserCreateResponseValidationError) 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 %sUserCreateResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserCreateResponseValidationError{}

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

// Validate checks the field values on UserGetRequest 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 *UserGetRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserGetRequest 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 UserGetRequestMultiError,
// or nil if none found.
func (m *UserGetRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if m.GetId() <= 0 {
		err := UserGetRequestValidationError{
			field:  "Id",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserGetRequestMultiError) 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 UserGetRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserGetRequestValidationError) 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 %sUserGetRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserGetRequestValidationError{}

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

// Validate checks the field values on UserGetResponse 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 *UserGetResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserGetResponse 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
// UserGetResponseMultiError, or nil if none found.
func (m *UserGetResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if all {
		switch v := interface{}(m.GetUser()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UserGetResponseValidationError{
					field:  "User",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UserGetResponseValidationError{
					field:  "User",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetUser()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UserGetResponseValidationError{
				field:  "User",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserGetResponseMultiError) 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 UserGetResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserGetResponseValidationError) 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 %sUserGetResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserGetResponseValidationError{}

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

// Validate checks the field values on UserQueryRequest 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 *UserQueryRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserQueryRequest 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
// UserQueryRequestMultiError, or nil if none found.
func (m *UserQueryRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if m.GetKeyword() != "" {

		if !_UserQueryRequest_Keyword_Pattern.MatchString(m.GetKeyword()) {
			err := UserQueryRequestValidationError{
				field:  "Keyword",
				reason: "value does not match regex pattern \"^\\\\s{1,10}$\"",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.GetPage() <= 0 {
		err := UserQueryRequestValidationError{
			field:  "Page",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.GetPageSize() <= 0 {
		err := UserQueryRequestValidationError{
			field:  "PageSize",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserQueryRequestMultiError) 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 UserQueryRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserQueryRequestValidationError) 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 %sUserQueryRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserQueryRequestValidationError{}

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

var _UserQueryRequest_Keyword_Pattern = regexp.MustCompile("^\\s{1,10}$")

// Validate checks the field values on UserQueryResponse 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 *UserQueryResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserQueryResponse 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
// UserQueryResponseMultiError, or nil if none found.
func (m *UserQueryResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if all {
		switch v := interface{}(m.GetPager()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UserQueryResponseValidationError{
					field:  "Pager",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UserQueryResponseValidationError{
					field:  "Pager",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPager()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UserQueryResponseValidationError{
				field:  "Pager",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UserQueryResponseValidationError{
						field:  fmt.Sprintf("User[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UserQueryResponseValidationError{
						field:  fmt.Sprintf("User[%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 UserQueryResponseValidationError{
					field:  fmt.Sprintf("User[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserQueryResponseMultiError) 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 UserQueryResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserQueryResponseValidationError) 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 %sUserQueryResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserQueryResponseValidationError{}

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

// Validate checks the field values on UserLoginRequest 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 *UserLoginRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserLoginRequest 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
// UserLoginRequestMultiError, or nil if none found.
func (m *UserLoginRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if !_UserLoginRequest_Nickname_Pattern.MatchString(m.GetNickname()) {
		err := UserLoginRequestValidationError{
			field:  "Nickname",
			reason: "value does not match regex pattern \".{2,30}\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UserLoginRequest_Password_Pattern.MatchString(m.GetPassword()) {
		err := UserLoginRequestValidationError{
			field:  "Password",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9]{1,17}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserLoginRequestMultiError) 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 UserLoginRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserLoginRequestValidationError) 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 %sUserLoginRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserLoginRequestValidationError{}

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

var _UserLoginRequest_Nickname_Pattern = regexp.MustCompile(".{2,30}")

var _UserLoginRequest_Password_Pattern = regexp.MustCompile("^[a-z][a-z0-9]{1,17}$")

// Validate checks the field values on UserLoginResponse 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 *UserLoginResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UserLoginResponse 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
// UserLoginResponseMultiError, or nil if none found.
func (m *UserLoginResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Token

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UserLoginResponseMultiError) 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 UserLoginResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UserLoginResponseValidationError) 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 %sUserLoginResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UserLoginResponseValidationError{}

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

// Validate checks the field values on UpdateAvatarRequest 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 *UpdateAvatarRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateAvatarRequest 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
// UpdateAvatarRequestMultiError, or nil if none found.
func (m *UpdateAvatarRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if uri, err := url.Parse(m.GetUrl()); err != nil {
		err = UpdateAvatarRequestValidationError{
			field:  "Url",
			reason: "value must be a valid URI",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	} else if !uri.IsAbs() {
		err := UpdateAvatarRequestValidationError{
			field:  "Url",
			reason: "value must be absolute",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UpdateAvatarRequest_Url_Pattern.MatchString(m.GetUrl()) {
		err := UpdateAvatarRequestValidationError{
			field:  "Url",
			reason: "value does not match regex pattern \"(jpg|jpeg|png)$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateAvatarRequestMultiError) 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 UpdateAvatarRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateAvatarRequestValidationError) 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 %sUpdateAvatarRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateAvatarRequestValidationError{}

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

var _UpdateAvatarRequest_Url_Pattern = regexp.MustCompile("(jpg|jpeg|png)$")

// Validate checks the field values on UpdateAvatarResponse 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 *UpdateAvatarResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateAvatarResponse 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
// UpdateAvatarResponseMultiError, or nil if none found.
func (m *UpdateAvatarResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateAvatarResponseMultiError) 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 UpdateAvatarResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateAvatarResponseValidationError) 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 %sUpdateAvatarResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateAvatarResponseValidationError{}

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

// Validate checks the field values on UpdatePasswordRequest 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 *UpdatePasswordRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdatePasswordRequest 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
// UpdatePasswordRequestMultiError, or nil if none found.
func (m *UpdatePasswordRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if !_UpdatePasswordRequest_Password_Pattern.MatchString(m.GetPassword()) {
		err := UpdatePasswordRequestValidationError{
			field:  "Password",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9]{1,17}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_UpdatePasswordRequest_PasswordRpt_Pattern.MatchString(m.GetPasswordRpt()) {
		err := UpdatePasswordRequestValidationError{
			field:  "PasswordRpt",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9]{1,17}$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UpdatePasswordRequestMultiError) 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 UpdatePasswordRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdatePasswordRequestValidationError) 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 %sUpdatePasswordRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdatePasswordRequestValidationError{}

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

var _UpdatePasswordRequest_Password_Pattern = regexp.MustCompile("^[a-z][a-z0-9]{1,17}$")

var _UpdatePasswordRequest_PasswordRpt_Pattern = regexp.MustCompile("^[a-z][a-z0-9]{1,17}$")

// Validate checks the field values on UpdatePasswordResponse 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 *UpdatePasswordResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdatePasswordResponse 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
// UpdatePasswordResponseMultiError, or nil if none found.
func (m *UpdatePasswordResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m UpdatePasswordResponseMultiError) 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 UpdatePasswordResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdatePasswordResponseValidationError) 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 %sUpdatePasswordResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdatePasswordResponseValidationError{}

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