user_center_field.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: user_center_field.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 Field 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 *Field) Validate() error {
	return m.validate(false)
}

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Keyword

	// no validation rules for Type

	// no validation rules for Name

	// no validation rules for Description

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = FieldValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PageFieldRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AllFieldTypeReplyValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CurrentFieldReplyValidationError{}

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

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PageFieldReplyValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddFieldRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddFieldReplyValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateFieldRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteFieldRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Type

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AllFieldTypeReplyDataValidationError{}

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