license.pb.validate.go

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

package license

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

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

	enterprise "github.com/pachyderm/pachyderm/v2/src/enterprise"
)

// 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

	_ = enterprise.State(0)
)

// 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 ActivationCode

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

	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

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetActivationCodeRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for State

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

	// no validation rules for ActivationCode

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetActivationCodeResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Address

	// no validation rules for Secret

	// no validation rules for UserAddress

	// no validation rules for ClusterDeploymentId

	// no validation rules for EnterpriseServer

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddClusterRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Secret

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AddClusterResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteClusterRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteClusterResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Address

	// no validation rules for Version

	// no validation rules for AuthEnabled

	// no validation rules for ClientId

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterStatusValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Address

	// no validation rules for UserAddress

	// no validation rules for ClusterDeploymentId

	// no validation rules for Secret

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateClusterRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateClusterResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListClustersRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListClustersResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteAllRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteAllResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Secret

	// no validation rules for Version

	// no validation rules for AuthEnabled

	// no validation rules for ClientId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = HeartbeatRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = HeartbeatResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for ClusterDeploymentId

	// no validation rules for Address

	// no validation rules for EnterpriseServer

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UserClusterInfoValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListUserClustersRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListUserClustersResponseValidationError{}

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