authz.pb.validate.go

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

package pb

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

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

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

	var errors []error

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

	if len(m.GetPublicKey()) < 1 {
		err := CertificateRequestValidationError{
			field:  "PublicKey",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CertificateRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

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

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

	}

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CSRValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for SerialNumber

	// no validation rules for CommonName

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SubjectValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Critical

	// no validation rules for Value

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ExtensionValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Ip

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = IPAddressValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Scheme

	// no validation rules for Opaque

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

	// no validation rules for Host

	// no validation rules for Path

	// no validation rules for RawPath

	// no validation rules for OmitHost

	// no validation rules for ForceQuery

	// no validation rules for RawQuery

	// no validation rules for Fragment

	// no validation rules for RawFragment

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = URLValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Username

	// no validation rules for Password

	// no validation rules for PasswordSet

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UserInfoValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Value

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AttributeValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Certificate

	// no validation rules for ExpiresOn

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CertificateResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListCertificatesResponseValidationError{}

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

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

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

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

	var errors []error

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

	if len(m.GetCertificate()) < 1 {
		err := VerificationRequestValidationError{
			field:  "Certificate",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = VerificationRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = VerificationResponseValidationError{}

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

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

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

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

	var errors []error

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

	if len(m.GetPublicKey()) < 1 {
		err := CertificateDeletionRequestValidationError{
			field:  "PublicKey",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(m.GetCertificate()) < 1 {
		err := CertificateDeletionRequestValidationError{
			field:  "Certificate",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CertificateDeletionRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CertificateDeletionResponseValidationError{}

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

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

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

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

	var errors []error

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

	if len(m.GetPublicKey()) < 1 {
		err := DeletionRequestValidationError{
			field:  "PublicKey",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeletionRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeletionResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RootCertificateRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Root

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RootCertificateResponseValidationError{}

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

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

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

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

	var errors []error

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

	if len(m.GetPublicKey()) < 1 {
		err := SignUpRequestValidationError{
			field:  "PublicKey",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SignUpRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Certificate

	if len(m.GetServiceCertificate()) < 1 {
		err := SignUpResponseValidationError{
			field:  "ServiceCertificate",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SignUpResponseValidationError{}

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

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

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

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

	var errors []error

	if len(m.GetIdCertificate()) < 1 {
		err := LoginRequestValidationError{
			field:  "IdCertificate",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(m.GetServiceCertificate()) < 1 {
		err := LoginRequestValidationError{
			field:  "ServiceCertificate",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = LoginRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Challenge

	// no validation rules for ExpiresOn

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = LoginResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Certificate

	if len(m.GetSignedChallenge()) < 1 {
		err := TokenRequestValidationError{
			field:  "SignedChallenge",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = TokenRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Token

	// no validation rules for ExpiresOn

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = TokenResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuthRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AuthResponseValidationError{}

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