experimental_service.pb.validate.go

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

package v1

import (
	"bytes"
	"errors"
	"fmt"
	"net"
	"net/mail"
	"net/url"
	"regexp"
	"sort"
	"strings"
	"time"
	"unicode/utf8"

	"google.golang.org/protobuf/types/known/anypb"
)

// ensure the imports are used
var (
	_ = bytes.MinRead
	_ = errors.New("")
	_ = fmt.Print
	_ = utf8.UTFMax
	_ = (*regexp.Regexp)(nil)
	_ = (*strings.Reader)(nil)
	_ = net.IPv4len
	_ = time.Duration(0)
	_ = (*url.URL)(nil)
	_ = (*mail.Address)(nil)
	_ = anypb.Any{}
	_ = sort.Sort
)

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

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

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

	var errors []error

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

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

		if item == nil {
			err := BulkCheckPermissionRequestValidationError{
				field:  fmt.Sprintf("Items[%v]", idx),
				reason: "value is required",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkCheckPermissionRequestValidationError{}

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

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

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

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

	var errors []error

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

	if len(m.GetPermission()) > 64 {
		err := BulkCheckPermissionRequestItemValidationError{
			field:  "Permission",
			reason: "value length must be at most 64 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_BulkCheckPermissionRequestItem_Permission_Pattern.MatchString(m.GetPermission()) {
		err := BulkCheckPermissionRequestItemValidationError{
			field:  "Permission",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])?$\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkCheckPermissionRequestItemValidationError{}

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

var _BulkCheckPermissionRequestItem_Permission_Pattern = regexp.MustCompile("^([a-z][a-z0-9_]{1,62}[a-z0-9])?$")

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

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

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

	var errors []error

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

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

		if item == nil {
			err := BulkCheckPermissionResponseValidationError{
				field:  fmt.Sprintf("Pairs[%v]", idx),
				reason: "value is required",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkCheckPermissionResponseValidationError{}

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

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

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

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

	var errors []error

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

	switch v := m.Response.(type) {
	case *BulkCheckPermissionPair_Item:
		if v == nil {
			err := BulkCheckPermissionPairValidationError{
				field:  "Response",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

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

	case *BulkCheckPermissionPair_Error:
		if v == nil {
			err := BulkCheckPermissionPairValidationError{
				field:  "Response",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

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

	default:
		_ = v // ensures v is used
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkCheckPermissionPairValidationError{}

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

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

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

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

	var errors []error

	if _, ok := _BulkCheckPermissionResponseItem_Permissionship_NotInLookup[m.GetPermissionship()]; ok {
		err := BulkCheckPermissionResponseItemValidationError{
			field:  "Permissionship",
			reason: "value must not be in list [PERMISSIONSHIP_UNSPECIFIED]",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if _, ok := CheckPermissionResponse_Permissionship_name[int32(m.GetPermissionship())]; !ok {
		err := BulkCheckPermissionResponseItemValidationError{
			field:  "Permissionship",
			reason: "value must be one of the defined enum values",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkCheckPermissionResponseItemValidationError{}

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

var _BulkCheckPermissionResponseItem_Permissionship_NotInLookup = map[CheckPermissionResponse_Permissionship]struct{}{
	0: {},
}

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

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

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

	var errors []error

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

		if item == nil {
			err := BulkImportRelationshipsRequestValidationError{
				field:  fmt.Sprintf("Relationships[%v]", idx),
				reason: "value is required",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkImportRelationshipsRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NumLoaded

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkImportRelationshipsResponseValidationError{}

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

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

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

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

	var errors []error

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

	if m.GetOptionalLimit() < 0 {
		err := BulkExportRelationshipsRequestValidationError{
			field:  "OptionalLimit",
			reason: "value must be greater than or equal to 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkExportRelationshipsRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BulkExportRelationshipsResponseValidationError{}

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