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

package query

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

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

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

	var errors []error

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

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

	}

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

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

	}

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Contains != nil {

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

	}

	if m.StartsWith != nil {

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

	}

	if m.NstartsWith != nil {

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

	}

	if m.EndsWith != nil {

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

	}

	if m.NendsWith != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

	if m.Empty != nil {

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

	}

	if m.Nempty != nil {

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

	}

	if m.Like != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = StringFilterOperationValidationError{}

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

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

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

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

	var errors []error

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BooleanFilterOperatorsValidationError{}

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

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

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

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

	var errors []error

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NullFilterOperatorsValidationError{}

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

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

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

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

	var errors []error

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Gt != nil {

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

	}

	if m.Gte != nil {

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

	}

	if m.Lt != nil {

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

	}

	if m.Lte != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DateFilterOperatorsValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

	}

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Gt != nil {

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

	}

	if m.Gte != nil {

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

	}

	if m.Lt != nil {

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

	}

	if m.Lte != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DoubleFilterOperatorsValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

	}

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Gt != nil {

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

	}

	if m.Gte != nil {

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

	}

	if m.Lt != nil {

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

	}

	if m.Lte != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = FloatFilterOperatorsValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

	}

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Gt != nil {

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

	}

	if m.Gte != nil {

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

	}

	if m.Lt != nil {

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

	}

	if m.Lte != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = Int64FilterOperatorsValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

	}

	if m.Eq != nil {

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

	}

	if m.Neq != nil {

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

	}

	if m.Gt != nil {

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

	}

	if m.Gte != nil {

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

	}

	if m.Lt != nil {

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

	}

	if m.Lte != nil {

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

	}

	if m.Null != nil {

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

	}

	if m.Nnull != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = Int32FilterOperatorsValidationError{}

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