auth.pb.validate.go

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

package auth

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

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

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

	var errors []error

	// no validation rules for RootToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ActivateRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PachToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ActivateResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeactivateRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeactivateResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RootToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RotateRootTokenRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RootToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RotateRootTokenResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Issuer

	// no validation rules for ClientId

	// no validation rules for ClientSecret

	// no validation rules for RedirectUri

	// no validation rules for RequireEmailVerified

	// no validation rules for LocalhostIssuer

	// no validation rules for UserAccessibleIssuerHost

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = OIDCConfigValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetConfigurationRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetConfigurationResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SetConfigurationRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SetConfigurationResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Subject

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

	// no validation rules for HashedToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = TokenInfoValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OidcState

	// no validation rules for IdToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuthenticateRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PachToken

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuthenticateResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = WhoAmIRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Username

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = WhoAmIResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Permission

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRolesForPermissionRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRolesForPermissionResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Roles

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RolesValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetEntries()))
		i := 0
		for key := range m.GetEntries() {
			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.GetEntries()[key]
			_ = val

			// no validation rules for Entries[key]

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

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RoleBindingValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Type

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ResourceValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Usernames

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UsersValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Groups

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GroupsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RoleValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuthorizeRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Authorized

	// no validation rules for Principal

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuthorizeResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetPermissionsRequestValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for Principal

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetPermissionsForPrincipalRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetPermissionsResponseValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for Principal

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModifyRoleBindingRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModifyRoleBindingResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRoleBindingRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRoleBindingResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Nonce

	// no validation rules for Email

	// no validation rules for ConversionErr

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SessionInfoValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetOIDCLoginRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for LoginUrl

	// no validation rules for State

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetOIDCLoginResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Robot

	// no validation rules for Ttl

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRobotTokenRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Token

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRobotTokenResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Token

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RevokeAuthTokenRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Number

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RevokeAuthTokenResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Username

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SetGroupsForUserRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SetGroupsForUserResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Group

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModifyMembersRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModifyMembersResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGroupsRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Principal

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGroupsForPrincipalRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGroupsResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Group

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetUsersRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetUsersResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ExtractAuthTokensRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ExtractAuthTokensResponseValidationError{}

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

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

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

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

	var errors []error

	if m.GetToken() == nil {
		err := RestoreAuthTokenRequestValidationError{
			field:  "Token",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreAuthTokenRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreAuthTokenResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Username

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RevokeAuthTokensForUserRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Number

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RevokeAuthTokensForUserResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteExpiredAuthTokensRequestValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DeleteExpiredAuthTokensRequestValidationError{}

// Validate checks the field values on DeleteExpiredAuthTokensResponse 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 *DeleteExpiredAuthTokensResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DeleteExpiredAuthTokensResponse 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
// DeleteExpiredAuthTokensResponseMultiError, or nil if none found.
func (m *DeleteExpiredAuthTokensResponse) ValidateAll() error {
	return m.validate(true)
}

func (m *DeleteExpiredAuthTokensResponse) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return DeleteExpiredAuthTokensResponseMultiError(errors)
	}

	return nil
}

// DeleteExpiredAuthTokensResponseMultiError is an error wrapping multiple
// validation errors returned by DeleteExpiredAuthTokensResponse.ValidateAll()
// if the designated constraints aren't met.
type DeleteExpiredAuthTokensResponseMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DeleteExpiredAuthTokensResponseMultiError) 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 DeleteExpiredAuthTokensResponseMultiError) AllErrors() []error { return m }

// DeleteExpiredAuthTokensResponseValidationError is the validation error
// returned by DeleteExpiredAuthTokensResponse.Validate if the designated
// constraints aren't met.
type DeleteExpiredAuthTokensResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e DeleteExpiredAuthTokensResponseValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e DeleteExpiredAuthTokensResponseValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e DeleteExpiredAuthTokensResponseValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e DeleteExpiredAuthTokensResponseValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e DeleteExpiredAuthTokensResponseValidationError) ErrorName() string {
	return "DeleteExpiredAuthTokensResponseValidationError"
}

// Error satisfies the builtin error interface
func (e DeleteExpiredAuthTokensResponseValidationError) 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 %sDeleteExpiredAuthTokensResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteExpiredAuthTokensResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DeleteExpiredAuthTokensResponseValidationError{}