request.pb.validate.go

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

package requestv1

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

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

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

	var errors []error

	// no validation rules for RequestId

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

	if m.GetPrincipal() == nil {
		err := PlanResourcesRequestValidationError{
			field:  "Principal",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetResource() == nil {
		err := PlanResourcesRequestValidationError{
			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, PlanResourcesRequestValidationError{
					field:  "Resource",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, PlanResourcesRequestValidationError{
					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 PlanResourcesRequestValidationError{
				field:  "Resource",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	// no validation rules for IncludeMeta

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PlanResourcesRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RequestId

	if len(m.GetActions()) < 1 {
		err := CheckResourceSetRequestValidationError{
			field:  "Actions",
			reason: "value must contain at least 1 item(s)",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	_CheckResourceSetRequest_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _CheckResourceSetRequest_Actions_Unique[item]; exists {
			err := CheckResourceSetRequestValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_CheckResourceSetRequest_Actions_Unique[item] = struct{}{}
		}

		if utf8.RuneCountInString(item) < 1 {
			err := CheckResourceSetRequestValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.GetPrincipal() == nil {
		err := CheckResourceSetRequestValidationError{
			field:  "Principal",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetResource() == nil {
		err := CheckResourceSetRequestValidationError{
			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, CheckResourceSetRequestValidationError{
					field:  "Resource",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, CheckResourceSetRequestValidationError{
					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 CheckResourceSetRequestValidationError{
				field:  "Resource",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for IncludeMeta

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CheckResourceSetRequestValidationError{}

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

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

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

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

	var errors []error

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

	if !_ResourceSet_Kind_Pattern.MatchString(m.GetKind()) {
		err := ResourceSetValidationError{
			field:  "Kind",
			reason: "value does not match regex pattern \"^[[:alpha:]][[:word:]\\\\@\\\\.\\\\-/]*(\\\\:[[:alpha:]][[:word:]\\\\@\\\\.\\\\-/]*)*$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_ResourceSet_PolicyVersion_Pattern.MatchString(m.GetPolicyVersion()) {
		err := ResourceSetValidationError{
			field:  "PolicyVersion",
			reason: "value does not match regex pattern \"^[[:word:]]*$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(m.GetInstances()) < 1 {
		err := ResourceSetValidationError{
			field:  "Instances",
			reason: "value must contain at least 1 pair(s)",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

			if val == nil {
				err := ResourceSetValidationError{
					field:  fmt.Sprintf("Instances[%v]", key),
					reason: "value cannot be sparse, all pairs must be non-nil",
				}
				if !all {
					return err
				}
				errors = append(errors, err)
			}

			// no validation rules for Instances[key]

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

		}
	}

	if !_ResourceSet_Scope_Pattern.MatchString(m.GetScope()) {
		err := ResourceSetValidationError{
			field:  "Scope",
			reason: "value does not match regex pattern \"^([[:alnum:]][[:word:]\\\\-]*(\\\\.[[:word:]\\\\-]*)*)*$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ResourceSetValidationError{}

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

var _ResourceSet_Kind_Pattern = regexp.MustCompile("^[[:alpha:]][[:word:]\\@\\.\\-/]*(\\:[[:alpha:]][[:word:]\\@\\.\\-/]*)*$")

var _ResourceSet_PolicyVersion_Pattern = regexp.MustCompile("^[[:word:]]*$")

var _ResourceSet_Scope_Pattern = regexp.MustCompile("^([[:alnum:]][[:word:]\\-]*(\\.[[:word:]\\-]*)*)*$")

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

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

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

	var errors []error

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

			if val == nil {
				err := AttributesMapValidationError{
					field:  fmt.Sprintf("Attr[%v]", key),
					reason: "value cannot be sparse, all pairs must be non-nil",
				}
				if !all {
					return err
				}
				errors = append(errors, err)
			}

			// no validation rules for Attr[key]

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

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AttributesMapValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RequestId

	if m.GetPrincipal() == nil {
		err := CheckResourceBatchRequestValidationError{
			field:  "Principal",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if len(m.GetResources()) < 1 {
		err := CheckResourceBatchRequestValidationError{
			field:  "Resources",
			reason: "value must contain at least 1 item(s)",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CheckResourceBatchRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RequestId

	// no validation rules for IncludeMeta

	if m.GetPrincipal() == nil {
		err := CheckResourcesRequestValidationError{
			field:  "Principal",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if len(m.GetResources()) < 1 {
		err := CheckResourcesRequestValidationError{
			field:  "Resources",
			reason: "value must contain at least 1 item(s)",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CheckResourcesRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuxDataValidationError{}

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

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

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

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

	var errors []error

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

	if l := len(m.GetContents()); l < 1 || l > 1048576 {
		err := FileValidationError{
			field:  "Contents",
			reason: "value length must be between 1 and 1048576 bytes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = FileValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PlaygroundId

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PlaygroundValidateRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PlaygroundId

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PlaygroundTestRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PlaygroundId

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

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

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

	}

	if m.GetPrincipal() == nil {
		err := PlaygroundEvaluateRequestValidationError{
			field:  "Principal",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if m.GetResource() == nil {
		err := PlaygroundEvaluateRequestValidationError{
			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, PlaygroundEvaluateRequestValidationError{
					field:  "Resource",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, PlaygroundEvaluateRequestValidationError{
					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 PlaygroundEvaluateRequestValidationError{
				field:  "Resource",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	_PlaygroundEvaluateRequest_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _PlaygroundEvaluateRequest_Actions_Unique[item]; exists {
			err := PlaygroundEvaluateRequestValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_PlaygroundEvaluateRequest_Actions_Unique[item] = struct{}{}
		}

		if utf8.RuneCountInString(item) < 1 {
			err := PlaygroundEvaluateRequestValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PlaygroundEvaluateRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PlaygroundId

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

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

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

	}

	oneofProxyRequestPresent := false
	switch v := m.ProxyRequest.(type) {
	case *PlaygroundProxyRequest_CheckResourceSet:
		if v == nil {
			err := PlaygroundProxyRequestValidationError{
				field:  "ProxyRequest",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofProxyRequestPresent = true

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

	case *PlaygroundProxyRequest_CheckResourceBatch:
		if v == nil {
			err := PlaygroundProxyRequestValidationError{
				field:  "ProxyRequest",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofProxyRequestPresent = true

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

	case *PlaygroundProxyRequest_PlanResources:
		if v == nil {
			err := PlaygroundProxyRequestValidationError{
				field:  "ProxyRequest",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofProxyRequestPresent = true

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

	case *PlaygroundProxyRequest_CheckResources:
		if v == nil {
			err := PlaygroundProxyRequestValidationError{
				field:  "ProxyRequest",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofProxyRequestPresent = true

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

	default:
		_ = v // ensures v is used
	}
	if !oneofProxyRequestPresent {
		err := PlaygroundProxyRequestValidationError{
			field:  "ProxyRequest",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PlaygroundProxyRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddOrUpdatePolicyRequestValidationError{}

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

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

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

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

	var errors []error

	if _, ok := _ListAuditLogEntriesRequest_Kind_InLookup[m.GetKind()]; !ok {
		err := ListAuditLogEntriesRequestValidationError{
			field:  "Kind",
			reason: "value must be in list [1 2]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	oneofFilterPresent := false
	switch v := m.Filter.(type) {
	case *ListAuditLogEntriesRequest_Tail:
		if v == nil {
			err := ListAuditLogEntriesRequestValidationError{
				field:  "Filter",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofFilterPresent = true

		if m.GetTail() > 1000 {
			err := ListAuditLogEntriesRequestValidationError{
				field:  "Tail",
				reason: "value must be less than or equal to 1000",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	case *ListAuditLogEntriesRequest_Between:
		if v == nil {
			err := ListAuditLogEntriesRequestValidationError{
				field:  "Filter",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofFilterPresent = true

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

	case *ListAuditLogEntriesRequest_Since:
		if v == nil {
			err := ListAuditLogEntriesRequestValidationError{
				field:  "Filter",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofFilterPresent = true

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

	case *ListAuditLogEntriesRequest_Lookup:
		if v == nil {
			err := ListAuditLogEntriesRequestValidationError{
				field:  "Filter",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		oneofFilterPresent = true

		if !_ListAuditLogEntriesRequest_Lookup_Pattern.MatchString(m.GetLookup()) {
			err := ListAuditLogEntriesRequestValidationError{
				field:  "Lookup",
				reason: "value does not match regex pattern \"^[0123456789ABCDEFGHJKMNPQRSTVWXYZ]{26}$\"",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	default:
		_ = v // ensures v is used
	}
	if !oneofFilterPresent {
		err := ListAuditLogEntriesRequestValidationError{
			field:  "Filter",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListAuditLogEntriesRequestValidationError{}

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

var _ListAuditLogEntriesRequest_Kind_InLookup = map[ListAuditLogEntriesRequest_Kind]struct{}{
	1: {},
	2: {},
}

var _ListAuditLogEntriesRequest_Lookup_Pattern = regexp.MustCompile("^[0123456789ABCDEFGHJKMNPQRSTVWXYZ]{26}$")

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerInfoRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for IncludeDisabled

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListPoliciesRequestValidationError{}

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

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

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

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

	var errors []error

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

	_GetPolicyRequest_Id_Unique := make(map[string]struct{}, len(m.GetId()))

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

		if _, exists := _GetPolicyRequest_Id_Unique[item]; exists {
			err := GetPolicyRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_GetPolicyRequest_Id_Unique[item] = struct{}{}
		}

		if l := utf8.RuneCountInString(item); l < 1 || l > 1280 {
			err := GetPolicyRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "value length must be between 1 and 1280 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetPolicyRequestValidationError{}

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

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

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

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

	var errors []error

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

	_DisablePolicyRequest_Id_Unique := make(map[string]struct{}, len(m.GetId()))

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

		if _, exists := _DisablePolicyRequest_Id_Unique[item]; exists {
			err := DisablePolicyRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_DisablePolicyRequest_Id_Unique[item] = struct{}{}
		}

		if l := utf8.RuneCountInString(item); l < 1 || l > 1280 {
			err := DisablePolicyRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "value length must be between 1 and 1280 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DisablePolicyRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddOrUpdateSchemaRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListSchemasRequestValidationError{}

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

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

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

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

	var errors []error

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

	_GetSchemaRequest_Id_Unique := make(map[string]struct{}, len(m.GetId()))

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

		if _, exists := _GetSchemaRequest_Id_Unique[item]; exists {
			err := GetSchemaRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_GetSchemaRequest_Id_Unique[item] = struct{}{}
		}

		if l := utf8.RuneCountInString(item); l < 1 || l > 255 {
			err := GetSchemaRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "value length must be between 1 and 255 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSchemaRequestValidationError{}

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

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

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

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

	var errors []error

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

	_DeleteSchemaRequest_Id_Unique := make(map[string]struct{}, len(m.GetId()))

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

		if _, exists := _DeleteSchemaRequest_Id_Unique[item]; exists {
			err := DeleteSchemaRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_DeleteSchemaRequest_Id_Unique[item] = struct{}{}
		}

		if l := utf8.RuneCountInString(item); l < 1 || l > 255 {
			err := DeleteSchemaRequestValidationError{
				field:  fmt.Sprintf("Id[%v]", idx),
				reason: "value length must be between 1 and 255 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteSchemaRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Wait

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ReloadStoreRequestValidationError{}

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

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

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

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

	var errors []error

	if len(m.GetActions()) < 1 {
		err := CheckResourceBatchRequest_BatchEntryValidationError{
			field:  "Actions",
			reason: "value must contain at least 1 item(s)",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	_CheckResourceBatchRequest_BatchEntry_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _CheckResourceBatchRequest_BatchEntry_Actions_Unique[item]; exists {
			err := CheckResourceBatchRequest_BatchEntryValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_CheckResourceBatchRequest_BatchEntry_Actions_Unique[item] = struct{}{}
		}

		if utf8.RuneCountInString(item) < 1 {
			err := CheckResourceBatchRequest_BatchEntryValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.GetResource() == nil {
		err := CheckResourceBatchRequest_BatchEntryValidationError{
			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, CheckResourceBatchRequest_BatchEntryValidationError{
					field:  "Resource",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, CheckResourceBatchRequest_BatchEntryValidationError{
					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 CheckResourceBatchRequest_BatchEntryValidationError{
				field:  "Resource",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CheckResourceBatchRequest_BatchEntryValidationError{}

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

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

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

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

	var errors []error

	if len(m.GetActions()) < 1 {
		err := CheckResourcesRequest_ResourceEntryValidationError{
			field:  "Actions",
			reason: "value must contain at least 1 item(s)",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	_CheckResourcesRequest_ResourceEntry_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _CheckResourcesRequest_ResourceEntry_Actions_Unique[item]; exists {
			err := CheckResourcesRequest_ResourceEntryValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {
			_CheckResourcesRequest_ResourceEntry_Actions_Unique[item] = struct{}{}
		}

		if utf8.RuneCountInString(item) < 1 {
			err := CheckResourcesRequest_ResourceEntryValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value length must be at least 1 runes",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.GetResource() == nil {
		err := CheckResourcesRequest_ResourceEntryValidationError{
			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, CheckResourcesRequest_ResourceEntryValidationError{
					field:  "Resource",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, CheckResourcesRequest_ResourceEntryValidationError{
					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 CheckResourcesRequest_ResourceEntryValidationError{
				field:  "Resource",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CheckResourcesRequest_ResourceEntryValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for KeySetId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuxData_JWTValidationError{}

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

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

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

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

	var errors []error

	if m.GetStart() == nil {
		err := ListAuditLogEntriesRequest_TimeRangeValidationError{
			field:  "Start",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if t := m.GetStart(); t != nil {
		ts, err := t.AsTime(), t.CheckValid()
		if err != nil {
			err = ListAuditLogEntriesRequest_TimeRangeValidationError{
				field:  "Start",
				reason: "value is not a valid timestamp",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {

			now := time.Now()

			if ts.Sub(now) >= 0 {
				err := ListAuditLogEntriesRequest_TimeRangeValidationError{
					field:  "Start",
					reason: "value must be less than now",
				}
				if !all {
					return err
				}
				errors = append(errors, err)
			}

		}
	}

	if m.GetEnd() == nil {
		err := ListAuditLogEntriesRequest_TimeRangeValidationError{
			field:  "End",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if t := m.GetEnd(); t != nil {
		ts, err := t.AsTime(), t.CheckValid()
		if err != nil {
			err = ListAuditLogEntriesRequest_TimeRangeValidationError{
				field:  "End",
				reason: "value is not a valid timestamp",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {

			now := time.Now()

			if ts.Sub(now) >= 0 {
				err := ListAuditLogEntriesRequest_TimeRangeValidationError{
					field:  "End",
					reason: "value must be less than now",
				}
				if !all {
					return err
				}
				errors = append(errors, err)
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListAuditLogEntriesRequest_TimeRangeValidationError{}

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