dispatch.pb.validate.go

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

package dispatchv1

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

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

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

	var errors []error

	if m.GetMetadata() == nil {
		err := DispatchCheckRequestValidationError{
			field:  "Metadata",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetResourceAndRelation() == nil {
		err := DispatchCheckRequestValidationError{
			field:  "ResourceAndRelation",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetSubject() == nil {
		err := DispatchCheckRequestValidationError{
			field:  "Subject",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchCheckRequestValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for Membership

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchCheckResponseValidationError{}

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

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

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

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

	var errors []error

	if m.GetMetadata() == nil {
		err := DispatchExpandRequestValidationError{
			field:  "Metadata",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetResourceAndRelation() == nil {
		err := DispatchExpandRequestValidationError{
			field:  "ResourceAndRelation",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	// no validation rules for ExpansionMode

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchExpandRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchExpandResponseValidationError{}

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

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

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

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

	var errors []error

	if m.GetMetadata() == nil {
		err := DispatchLookupRequestValidationError{
			field:  "Metadata",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetObjectRelation() == nil {
		err := DispatchLookupRequestValidationError{
			field:  "ObjectRelation",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetSubject() == nil {
		err := DispatchLookupRequestValidationError{
			field:  "Subject",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	// no validation rules for Limit

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchLookupRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

	// no validation rules for NextPageReference

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchLookupResponseValidationError{}

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

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

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

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

	var errors []error

	if m.GetMetadata() == nil {
		err := DispatchReachableResourcesRequestValidationError{
			field:  "Metadata",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetObjectRelation() == nil {
		err := DispatchReachableResourcesRequestValidationError{
			field:  "ObjectRelation",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetSubject() == nil {
		err := DispatchReachableResourcesRequestValidationError{
			field:  "Subject",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchReachableResourcesRequestValidationError{}

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

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

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

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

	var errors []error

	if m.GetResource() == nil {
		err := ReachableResourceValidationError{
			field:  "Resource",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	// no validation rules for ResultStatus

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ReachableResourceValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DispatchReachableResourcesResponseValidationError{}

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

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

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

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

	var errors []error

	if !_ResolverMeta_AtRevision_Pattern.MatchString(m.GetAtRevision()) {
		err := ResolverMetaValidationError{
			field:  "AtRevision",
			reason: "value does not match regex pattern \"^[0-9]+(\\\\.[0-9]+)?$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ResolverMetaValidationError{}

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

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

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

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

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

	var errors []error

	// no validation rules for DispatchCount

	// no validation rules for DepthRequired

	// no validation rules for CachedDispatchCount

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ResponseMetaValidationError{}

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