user_center_user.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: user_center_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
)

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

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

func (m *SimpleUser) 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 Avatar

	// no validation rules for Gender

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SimpleUserValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSimpleUserRequestValidationError{}

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

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

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

func (m *BaseUser) 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 RealName

	// no validation rules for Avatar

	// no validation rules for Gender

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

	if m.Phone != nil {
		// no validation rules for Phone
	}

	if m.Email != nil {
		// no validation rules for Email
	}

	if m.Username != nil {
		// no validation rules for Username
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BaseUserValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetBaseUserRequestValidationError{}

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

// 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 RealName

	// no validation rules for Avatar

	// no validation rules for Gender

	// no validation rules for Status

	// no validation rules for From

	// no validation rules for FromDesc

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

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

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

	}

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

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

	}

	{
		sorted_keys := make([]string, len(m.GetExtra()))
		i := 0
		for key := range m.GetExtra() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetExtra()[key]
			_ = val

			// no validation rules for Extra[key]

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

		}
	}

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

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

	}

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

	if m.Phone != nil {
		// no validation rules for Phone
	}

	if m.Email != nil {
		// no validation rules for Email
	}

	if m.Username != nil {
		// no validation rules for Username
	}

	if m.IdCard != nil {
		// no validation rules for IdCard
	}

	if m.DisableDesc != nil {
		// no validation rules for DisableDesc
	}

	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 PageUserRequest 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 *PageUserRequest) Validate() error {
	return m.validate(false)
}

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

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

	var errors []error

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

	if val := m.GetPageSize(); val <= 0 || val > 50 {
		err := PageUserRequestValidationError{
			field:  "PageSize",
			reason: "value must be inside range (0, 50]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.App != nil {
		// no validation rules for App
	}

	if m.Username != nil {
		// no validation rules for Username
	}

	if m.Phone != nil {
		// no validation rules for Phone
	}

	if m.Email != nil {
		// no validation rules for Email
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PageUserRequestValidationError{}

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

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

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

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

	var errors []error

	switch v := m.Condition.(type) {
	case *GetUserRequest_Phone:
		if v == nil {
			err := GetUserRequestValidationError{
				field:  "Condition",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Phone
	case *GetUserRequest_Email:
		if v == nil {
			err := GetUserRequestValidationError{
				field:  "Condition",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Email
	case *GetUserRequest_Username:
		if v == nil {
			err := GetUserRequestValidationError{
				field:  "Condition",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Username
	case *GetUserRequest_Id:
		if v == nil {
			err := GetUserRequestValidationError{
				field:  "Condition",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Id
	default:
		_ = v // ensures v is used
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetUserRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Total

	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, PageUserReplyValidationError{
						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, PageUserReplyValidationError{
						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 PageUserReplyValidationError{
					field:  fmt.Sprintf("List[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PageUserReplyValidationError{}

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

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

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

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

	var errors []error

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

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

	}

	if m.Phone != nil {

		if utf8.RuneCountInString(m.GetPhone()) != 11 {
			err := AddUserRequestValidationError{
				field:  "Phone",
				reason: "value length must be 11 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)

		}

	}

	if m.Email != nil {

		if err := m._validateEmail(m.GetEmail()); err != nil {
			err = AddUserRequestValidationError{
				field:  "Email",
				reason: "value must be a valid email address",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Username != nil {

		if utf8.RuneCountInString(m.GetUsername()) < 6 {
			err := AddUserRequestValidationError{
				field:  "Username",
				reason: "value length must be at least 6 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Password != nil {

		if utf8.RuneCountInString(m.GetPassword()) < 6 {
			err := AddUserRequestValidationError{
				field:  "Password",
				reason: "value length must be at least 6 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.NickName != nil {

		if utf8.RuneCountInString(m.GetNickName()) < 1 {
			err := AddUserRequestValidationError{
				field:  "NickName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.RealName != nil {

		if utf8.RuneCountInString(m.GetRealName()) < 1 {
			err := AddUserRequestValidationError{
				field:  "RealName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Avatar != nil {

		if utf8.RuneCountInString(m.GetAvatar()) > 128 {
			err := AddUserRequestValidationError{
				field:  "Avatar",
				reason: "value length must be at most 128 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Gender != nil {

		if _, ok := _AddUserRequest_Gender_InLookup[m.GetGender()]; !ok {
			err := AddUserRequestValidationError{
				field:  "Gender",
				reason: "value must be in list [M F U]",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.From != nil {

		if utf8.RuneCountInString(m.GetFrom()) < 1 {
			err := AddUserRequestValidationError{
				field:  "From",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.FromDesc != nil {

		if utf8.RuneCountInString(m.GetFromDesc()) < 1 {
			err := AddUserRequestValidationError{
				field:  "FromDesc",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

func (m *AddUserRequest) _validateHostname(host string) error {
	s := strings.ToLower(strings.TrimSuffix(host, "."))

	if len(host) > 253 {
		return errors.New("hostname cannot exceed 253 characters")
	}

	for _, part := range strings.Split(s, ".") {
		if l := len(part); l == 0 || l > 63 {
			return errors.New("hostname part must be non-empty and cannot exceed 63 characters")
		}

		if part[0] == '-' {
			return errors.New("hostname parts cannot begin with hyphens")
		}

		if part[len(part)-1] == '-' {
			return errors.New("hostname parts cannot end with hyphens")
		}

		for _, r := range part {
			if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
				return fmt.Errorf("hostname parts can only contain alphanumeric characters or hyphens, got %q", string(r))
			}
		}
	}

	return nil
}

func (m *AddUserRequest) _validateEmail(addr string) error {
	a, err := mail.ParseAddress(addr)
	if err != nil {
		return err
	}
	addr = a.Address

	if len(addr) > 254 {
		return errors.New("email addresses cannot exceed 254 characters")
	}

	parts := strings.SplitN(addr, "@", 2)

	if len(parts[0]) > 64 {
		return errors.New("email address local phrase cannot exceed 64 characters")
	}

	return m._validateHostname(parts[1])
}

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

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

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

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

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

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

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

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

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

var _ error = AddUserRequestValidationError{}

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

var _AddUserRequest_Gender_InLookup = map[string]struct{}{
	"M": {},
	"F": {},
	"U": {},
}

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

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

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

	var errors []error

	if l := len(m.GetList()); l < 1 || l > 1000 {
		err := ImportUserRequestValidationError{
			field:  "List",
			reason: "value must contain between 1 and 1000 items, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	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, ImportUserRequestValidationError{
						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, ImportUserRequestValidationError{
						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 ImportUserRequestValidationError{
					field:  fmt.Sprintf("List[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ImportUserRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddUserReplyValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetExtra()))
		i := 0
		for key := range m.GetExtra() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetExtra()[key]
			_ = val

			// no validation rules for Extra[key]

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

		}
	}

	if m.Phone != nil {

		if utf8.RuneCountInString(m.GetPhone()) != 11 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "Phone",
				reason: "value length must be 11 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)

		}

	}

	if m.Email != nil {

		if err := m._validateEmail(m.GetEmail()); err != nil {
			err = UpdateCurrentUserRequestValidationError{
				field:  "Email",
				reason: "value must be a valid email address",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Username != nil {

		if utf8.RuneCountInString(m.GetUsername()) < 6 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "Username",
				reason: "value length must be at least 6 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Password != nil {

		if utf8.RuneCountInString(m.GetPassword()) < 6 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "Password",
				reason: "value length must be at least 6 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.NickName != nil {

		if utf8.RuneCountInString(m.GetNickName()) < 1 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "NickName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.RealName != nil {

		if utf8.RuneCountInString(m.GetRealName()) < 1 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "RealName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.IdCard != nil {

		if l := utf8.RuneCountInString(m.GetIdCard()); l < 15 || l > 18 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "IdCard",
				reason: "value length must be between 15 and 18 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Avatar != nil {

		if utf8.RuneCountInString(m.GetAvatar()) > 128 {
			err := UpdateCurrentUserRequestValidationError{
				field:  "Avatar",
				reason: "value length must be at most 128 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Gender != nil {

		if _, ok := _UpdateCurrentUserRequest_Gender_InLookup[m.GetGender()]; !ok {
			err := UpdateCurrentUserRequestValidationError{
				field:  "Gender",
				reason: "value must be in list [M F U]",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

func (m *UpdateCurrentUserRequest) _validateHostname(host string) error {
	s := strings.ToLower(strings.TrimSuffix(host, "."))

	if len(host) > 253 {
		return errors.New("hostname cannot exceed 253 characters")
	}

	for _, part := range strings.Split(s, ".") {
		if l := len(part); l == 0 || l > 63 {
			return errors.New("hostname part must be non-empty and cannot exceed 63 characters")
		}

		if part[0] == '-' {
			return errors.New("hostname parts cannot begin with hyphens")
		}

		if part[len(part)-1] == '-' {
			return errors.New("hostname parts cannot end with hyphens")
		}

		for _, r := range part {
			if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
				return fmt.Errorf("hostname parts can only contain alphanumeric characters or hyphens, got %q", string(r))
			}
		}
	}

	return nil
}

func (m *UpdateCurrentUserRequest) _validateEmail(addr string) error {
	a, err := mail.ParseAddress(addr)
	if err != nil {
		return err
	}
	addr = a.Address

	if len(addr) > 254 {
		return errors.New("email addresses cannot exceed 254 characters")
	}

	parts := strings.SplitN(addr, "@", 2)

	if len(parts[0]) > 64 {
		return errors.New("email address local phrase cannot exceed 64 characters")
	}

	return m._validateHostname(parts[1])
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateCurrentUserRequestValidationError{}

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

var _UpdateCurrentUserRequest_Gender_InLookup = map[string]struct{}{
	"M": {},
	"F": {},
	"U": {},
}

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

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

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

	var errors []error

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

	if m.Phone != nil {

		if utf8.RuneCountInString(m.GetPhone()) != 11 {
			err := UpdateUserRequestValidationError{
				field:  "Phone",
				reason: "value length must be 11 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)

		}

	}

	if m.Email != nil {

		if err := m._validateEmail(m.GetEmail()); err != nil {
			err = UpdateUserRequestValidationError{
				field:  "Email",
				reason: "value must be a valid email address",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Username != nil {

		if utf8.RuneCountInString(m.GetUsername()) < 6 {
			err := UpdateUserRequestValidationError{
				field:  "Username",
				reason: "value length must be at least 6 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Password != nil {

		if utf8.RuneCountInString(m.GetPassword()) < 6 {
			err := UpdateUserRequestValidationError{
				field:  "Password",
				reason: "value length must be at least 6 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.NickName != nil {

		if utf8.RuneCountInString(m.GetNickName()) < 1 {
			err := UpdateUserRequestValidationError{
				field:  "NickName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.RealName != nil {

		if utf8.RuneCountInString(m.GetRealName()) < 1 {
			err := UpdateUserRequestValidationError{
				field:  "RealName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.IdCard != nil {

		if l := utf8.RuneCountInString(m.GetIdCard()); l < 15 || l > 18 {
			err := UpdateUserRequestValidationError{
				field:  "IdCard",
				reason: "value length must be between 15 and 18 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Avatar != nil {

		if utf8.RuneCountInString(m.GetAvatar()) > 128 {
			err := UpdateUserRequestValidationError{
				field:  "Avatar",
				reason: "value length must be at most 128 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Gender != nil {

		if _, ok := _UpdateUserRequest_Gender_InLookup[m.GetGender()]; !ok {
			err := UpdateUserRequestValidationError{
				field:  "Gender",
				reason: "value must be in list [M F U]",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

func (m *UpdateUserRequest) _validateHostname(host string) error {
	s := strings.ToLower(strings.TrimSuffix(host, "."))

	if len(host) > 253 {
		return errors.New("hostname cannot exceed 253 characters")
	}

	for _, part := range strings.Split(s, ".") {
		if l := len(part); l == 0 || l > 63 {
			return errors.New("hostname part must be non-empty and cannot exceed 63 characters")
		}

		if part[0] == '-' {
			return errors.New("hostname parts cannot begin with hyphens")
		}

		if part[len(part)-1] == '-' {
			return errors.New("hostname parts cannot end with hyphens")
		}

		for _, r := range part {
			if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
				return fmt.Errorf("hostname parts can only contain alphanumeric characters or hyphens, got %q", string(r))
			}
		}
	}

	return nil
}

func (m *UpdateUserRequest) _validateEmail(addr string) error {
	a, err := mail.ParseAddress(addr)
	if err != nil {
		return err
	}
	addr = a.Address

	if len(addr) > 254 {
		return errors.New("email addresses cannot exceed 254 characters")
	}

	parts := strings.SplitN(addr, "@", 2)

	if len(parts[0]) > 64 {
		return errors.New("email address local phrase cannot exceed 64 characters")
	}

	return m._validateHostname(parts[1])
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateUserRequestValidationError{}

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

var _UpdateUserRequest_Gender_InLookup = map[string]struct{}{
	"M": {},
	"F": {},
	"U": {},
}

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteUserRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = OfflineUserRequestValidationError{}

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

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

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

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

	var errors []error

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

	if utf8.RuneCountInString(m.GetDesc()) < 1 {
		err := DisableUserRequestValidationError{
			field:  "Desc",
			reason: "value length must be at least 1 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DisableUserRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = EnableUserRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Name

	// no validation rules for Logo

	// no validation rules for CreatedAt

	// no validation rules for LoginAt

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = User_AppValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Name

	// no validation rules for Logo

	// no validation rules for CreatedAt

	// no validation rules for LoginAt

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = User_ChannelValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Keyword

	// no validation rules for Type

	// no validation rules for TypeName

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = User_ExtraValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for UserId

	// no validation rules for Keyword

	// no validation rules for Type

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

	// no validation rules for CreatedAt

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddUserRequest_UserExtraValidationError{}

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

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

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

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

	var errors []error

	if _, ok := _ImportUserRequestData_Gender_InLookup[m.GetGender()]; !ok {
		err := ImportUserRequestDataValidationError{
			field:  "Gender",
			reason: "value must be in list [M F U]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.Phone != nil {

		if utf8.RuneCountInString(m.GetPhone()) != 11 {
			err := ImportUserRequestDataValidationError{
				field:  "Phone",
				reason: "value length must be 11 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)

		}

	}

	if m.Email != nil {

		if err := m._validateEmail(m.GetEmail()); err != nil {
			err = ImportUserRequestDataValidationError{
				field:  "Email",
				reason: "value must be a valid email address",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.RealName != nil {

		if utf8.RuneCountInString(m.GetRealName()) < 1 {
			err := ImportUserRequestDataValidationError{
				field:  "RealName",
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

func (m *ImportUserRequestData) _validateHostname(host string) error {
	s := strings.ToLower(strings.TrimSuffix(host, "."))

	if len(host) > 253 {
		return errors.New("hostname cannot exceed 253 characters")
	}

	for _, part := range strings.Split(s, ".") {
		if l := len(part); l == 0 || l > 63 {
			return errors.New("hostname part must be non-empty and cannot exceed 63 characters")
		}

		if part[0] == '-' {
			return errors.New("hostname parts cannot begin with hyphens")
		}

		if part[len(part)-1] == '-' {
			return errors.New("hostname parts cannot end with hyphens")
		}

		for _, r := range part {
			if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
				return fmt.Errorf("hostname parts can only contain alphanumeric characters or hyphens, got %q", string(r))
			}
		}
	}

	return nil
}

func (m *ImportUserRequestData) _validateEmail(addr string) error {
	a, err := mail.ParseAddress(addr)
	if err != nil {
		return err
	}
	addr = a.Address

	if len(addr) > 254 {
		return errors.New("email addresses cannot exceed 254 characters")
	}

	parts := strings.SplitN(addr, "@", 2)

	if len(parts[0]) > 64 {
		return errors.New("email address local phrase cannot exceed 64 characters")
	}

	return m._validateHostname(parts[1])
}

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

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

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

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

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

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

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

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

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

var _ error = ImportUserRequestDataValidationError{}

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

var _ImportUserRequestData_Gender_InLookup = map[string]struct{}{
	"M": {},
	"F": {},
	"U": {},
}