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

package console

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ProjectId

	// no validation rules for ClusterId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRestoreProgressRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Percent

	// no validation rules for SizeBytes

	// no validation rules for State

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRestoreProgressResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreStateValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for BackupId

	// no validation rules for ClusterId

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

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

	// no validation rules for State

	// no validation rules for Type

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BackupValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ClusterId

	// no validation rules for DisplayName

	// no validation rules for ProjectId

	// no validation rules for Region

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

	// no validation rules for EnhancedEncryptionEnabled

	// no validation rules for ZoneRedundantEnabled

	// no validation rules for Provider

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RecycledInstanceValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = BackupStateTypeValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ProjectId

	// no validation rules for ClusterId

	// no validation rules for PageSize

	// no validation rules for PageToken

	// no validation rules for OrderBy

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListBackupsRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

	// no validation rules for NextPageToken

	// no validation rules for TotalSize

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListBackupsResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ProjectId

	// no validation rules for ClusterId

	// no validation rules for BackupId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetBackupRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for PageSize

	// no validation rules for PageToken

	// no validation rules for OrderBy

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListRecycledInstancesRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

	// no validation rules for NextPageToken

	// no validation rules for TotalSize

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListRecycledInstancesResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ClusterId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetRecycledInstanceRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ClusterId

	// no validation rules for PageSize

	// no validation rules for PageToken

	// no validation rules for OrderBy

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListRecycledInstanceBackupsRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

	// no validation rules for NextPageToken

	// no validation rules for TotalSize

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListRecycledInstanceBackupsResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ClusterId

	// no validation rules for BackupId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteRecycledInstanceBackupRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteRecycledInstanceBackupResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreTypeValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreClusterHighAvailabilityTypeValidationError{}

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

// Validate checks the field values on Cluster with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *Cluster) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on Cluster with the rules defined in the
// proto definition for this message. If any rules are violated, the result is
// a list of violation errors wrapped in ClusterMultiError, or nil if none found.
func (m *Cluster) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for DisplayName

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

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

	// no validation rules for HighAvailabilityType

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m ClusterMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ClusterMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ClusterValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCluster.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ClusterValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ProjectId

	// no validation rules for Type

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

	switch v := m.Source.(type) {
	case *RestoreRequest_BackupId:
		if v == nil {
			err := RestoreRequestValidationError{
				field:  "Source",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for BackupId
	case *RestoreRequest_PointInTime:
		if v == nil {
			err := RestoreRequestValidationError{
				field:  "Source",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ClusterId

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PointInTimeValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ClusterId

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RestoreResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ProjectId

	// no validation rules for ClusterId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetBackupRetentionReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RetentionHours

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetBackupRetentionRespValidationError{}

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

// Validate checks the field values on Cluster_SpendingLimit with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *Cluster_SpendingLimit) Validate() error {
	return m.validate(false)
}

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

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

	var errors []error

	// no validation rules for Monthly

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

	return nil
}

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

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

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e Cluster_SpendingLimitValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCluster_SpendingLimit.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = Cluster_SpendingLimitValidationError{}

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

// Validate checks the field values on Cluster_AutoScaling with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *Cluster_AutoScaling) Validate() error {
	return m.validate(false)
}

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

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

	var errors []error

	// no validation rules for MinRcu

	// no validation rules for MaxRcu

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

	return nil
}

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

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

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e Cluster_AutoScalingValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCluster_AutoScaling.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = Cluster_AutoScalingValidationError{}

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