cluster.pb.validate.go

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

package apiv1

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
)

// define the regex for a UUID once up-front
var _cluster_uuidPattern = regexp.MustCompile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ClusterValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 12 {
		err := ClusterValidationError{
			field:  "Name",
			reason: "value length must be between 2 and 12 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Partition

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

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

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

	}

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

	// no validation rules for Tenant

	if all {
		switch v := interface{}(m.GetCreatedAt()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ClusterValidationError{
					field:  "CreatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ClusterValidationError{
					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 ClusterValidationError{
				field:  "CreatedAt",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

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

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

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

	if m.Purpose != nil {
		// no validation rules for Purpose
	}

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

	return nil
}

func (m *Cluster) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterValidationError{}

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

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

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

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

	var errors []error

	if len(m.GetVersion()) > 8 {
		err := KubernetesSpecValidationError{
			field:  "Version",
			reason: "value length must be at most 8 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if !_KubernetesSpec_Version_Pattern.MatchString(m.GetVersion()) {
		err := KubernetesSpecValidationError{
			field:  "Version",
			reason: "value does not match regex pattern \"[0-9]+.[0-9]+.[0-9]\"",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = KubernetesSpecValidationError{}

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

var _KubernetesSpec_Version_Pattern = regexp.MustCompile("[0-9]+.[0-9]+.[0-9]")

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

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

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

	var errors []error

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

	if m.KubernetesAutoupdate != nil {
		// no validation rules for KubernetesAutoupdate
	}

	if m.MachineimageAutoupdate != nil {
		// no validation rules for MachineimageAutoupdate
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = MaintenanceValidationError{}

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

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

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

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

	var errors []error

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

	if d := m.GetDuration(); d != nil {
		dur, err := d.AsDuration(), d.CheckValid()
		if err != nil {
			err = MaintenanceTimeWindowValidationError{
				field:  "Duration",
				reason: "value is not a valid duration",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		} else {

			lt := time.Duration(14400*time.Second + 0*time.Nanosecond)
			gte := time.Duration(3600*time.Second + 0*time.Nanosecond)

			if dur < gte || dur >= lt {
				err := MaintenanceTimeWindowValidationError{
					field:  "Duration",
					reason: "value must be inside range [1h0m0s, 4h0m0s)",
				}
				if !all {
					return err
				}
				errors = append(errors, err)
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = MaintenanceTimeWindowValidationError{}

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

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

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

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

	var errors []error

	if m.GetHour() > 24 {
		err := TimeValidationError{
			field:  "Hour",
			reason: "value must be less than or equal to 24",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.GetMinute() > 60 {
		err := TimeValidationError{
			field:  "Minute",
			reason: "value must be less than or equal to 60",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Timezone

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = TimeValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 128 {
		err := WorkerValidationError{
			field:  "Name",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetMachineType()); l < 2 || l > 128 {
		err := WorkerValidationError{
			field:  "MachineType",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.GetMinsize() > 32 {
		err := WorkerValidationError{
			field:  "Minsize",
			reason: "value must be less than or equal to 32",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.GetMaxsize() > 64 {
		err := WorkerValidationError{
			field:  "Maxsize",
			reason: "value must be less than or equal to 64",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.GetMaxsurge() > 64 {
		err := WorkerValidationError{
			field:  "Maxsurge",
			reason: "value must be less than or equal to 64",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.GetMaxunavailable() > 64 {
		err := WorkerValidationError{
			field:  "Maxunavailable",
			reason: "value must be less than or equal to 64",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = WorkerValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 128 {
		err := WorkerUpdateValidationError{
			field:  "Name",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.MachineType != nil {

		if l := utf8.RuneCountInString(m.GetMachineType()); l < 2 || l > 128 {
			err := WorkerUpdateValidationError{
				field:  "MachineType",
				reason: "value length must be between 2 and 128 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Minsize != nil {

		if m.GetMinsize() > 32 {
			err := WorkerUpdateValidationError{
				field:  "Minsize",
				reason: "value must be less than or equal to 32",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Maxsize != nil {

		if m.GetMaxsize() > 64 {
			err := WorkerUpdateValidationError{
				field:  "Maxsize",
				reason: "value must be less than or equal to 64",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Maxsurge != nil {

		if m.GetMaxsurge() > 64 {
			err := WorkerUpdateValidationError{
				field:  "Maxsurge",
				reason: "value must be less than or equal to 64",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Maxunavailable != nil {

		if m.GetMaxunavailable() > 64 {
			err := WorkerUpdateValidationError{
				field:  "Maxunavailable",
				reason: "value must be less than or equal to 64",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = WorkerUpdateValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ClusterServiceGetRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceGetRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *ClusterServiceGetRequest) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceGetRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ClusterServiceOperateRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceOperateRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Operate

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

	return nil
}

func (m *ClusterServiceOperateRequest) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceOperateRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ClusterServiceGetCredentialsRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceGetCredentialsRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.Expiration != nil {

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

	}

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

	return nil
}

func (m *ClusterServiceGetCredentialsRequest) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceGetCredentialsRequestValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceListRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceListRequestValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 12 {
		err := ClusterServiceCreateRequestValidationError{
			field:  "Name",
			reason: "value length must be between 2 and 12 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if err := m._validateHostname(m.GetName()); err != nil {
		err = ClusterServiceCreateRequestValidationError{
			field:  "Name",
			reason: "value must be a valid hostname",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceCreateRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Partition

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

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

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

	}

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

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

	return nil
}

func (m *ClusterServiceCreateRequest) _validateHostname(host string) error {
	s := strings.ToLower(strings.TrimSuffix(host, "."))

	if len(host) > 253 {
		return errors.New("hostname cannot exceed 253 characters")
	}

	for _, part := range strings.Split(s, ".") {
		if l := len(part); l == 0 || l > 63 {
			return errors.New("hostname part must be non-empty and cannot exceed 63 characters")
		}

		if part[0] == '-' {
			return errors.New("hostname parts cannot begin with hyphens")
		}

		if part[len(part)-1] == '-' {
			return errors.New("hostname parts cannot end with hyphens")
		}

		for _, r := range part {
			if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
				return fmt.Errorf("hostname parts can only contain alphanumeric characters or hyphens, got %q", string(r))
			}
		}
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceCreateRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ClusterServiceUpdateRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceUpdateRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	}

	if m.Kubernetes != nil {

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

	}

	if m.Maintenance != nil {

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

	}

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

	return nil
}

func (m *ClusterServiceUpdateRequest) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceUpdateRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = ClusterServiceDeleteRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceDeleteRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *ClusterServiceDeleteRequest) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceDeleteRequestValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := ClusterServiceWatchStatusRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.Uuid != nil {

		if err := m._validateUuid(m.GetUuid()); err != nil {
			err = ClusterServiceWatchStatusRequestValidationError{
				field:  "Uuid",
				reason: "value must be a valid UUID",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

func (m *ClusterServiceWatchStatusRequest) _validateUuid(uuid string) error {
	if matched := _cluster_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceWatchStatusRequestValidationError{}

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

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

	// no validation rules for Progress

	// no validation rules for State

	// no validation rules for Type

	// no validation rules for ApiServerReady

	// no validation rules for ControlPlaneReady

	// no validation rules for NodesReady

	// no validation rules for SystemComponentsReady

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

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

	}

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

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

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

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

	var errors []error

	// no validation rules for Description

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

	if m.TaskId != nil {
		// no validation rules for TaskId
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterStatusLastErrorValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Type

	// no validation rules for Status

	// no validation rules for Reason

	// no validation rules for StatusMessage

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterStatusConditionValidationError{}

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

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

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

func (m *ClusterMonitoring) 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 Endpoint

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterMonitoringValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceCreateResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceGetResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Kubeconfig

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceGetCredentialsResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceDeleteResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceUpdateResponseValidationError{}

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

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

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

func (m *ClusterServiceListResponse) 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, ClusterServiceListResponseValidationError{
						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, ClusterServiceListResponseValidationError{
						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 ClusterServiceListResponseValidationError{
					field:  fmt.Sprintf("Clusters[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceListResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceWatchStatusResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ClusterServiceOperateResponseValidationError{}

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