autoscale.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: aperture/policy/language/v1/autoscale.proto

package languagev1

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

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

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

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

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

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

	var errors []error

	// no validation rules for AgentGroup

	// no validation rules for Namespace

	// no validation rules for ApiVersion

	// no validation rules for Kind

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = KubernetesObjectSelectorValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AutoScaleValidationError{}

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

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

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

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

	var errors []error

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

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

	// no validation rules for DryRun

	// no validation rules for DryRunConfigKey

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PodScalerValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = IncreasingGradientValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DecreasingGradientValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for ScaleInPercentage

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PeriodicDecreaseValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ScaleOutControllerValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ScaleInControllerValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

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

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

	}

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

	// no validation rules for DryRun

	// no validation rules for DryRunConfigKey

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AutoScalerValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PodScaler_InsValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PodScaler_OutsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Slope

	// no validation rules for MaxGradient

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = IncreasingGradient_ParametersValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = IncreasingGradient_InsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Slope

	// no validation rules for MinGradient

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DecreasingGradient_ParametersValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DecreasingGradient_InsValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ScaleOutController_ControllerValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ScaleInController_ControllerValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for MaxScaleOutPercentage

	// no validation rules for MaxScaleInPercentage

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

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

	// no validation rules for CooldownOverridePercentage

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AutoScaler_ScalingParametersValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AutoScaler_ScalingBackendValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for MinReplicas

	// no validation rules for MaxReplicas

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AutoScaler_ScalingBackend_KubernetesReplicasValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = AutoScaler_ScalingBackend_KubernetesReplicas_OutsValidationError{}

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