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

package serverless

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for ProjectId

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetAllSpendLimitsReqValidationError{}

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

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

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

func (m *GetSpendLimitReq) 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 GetSpendLimitReqMultiError(errors)
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSpendLimitReqValidationError{}

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

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

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

func (m *SetSpendLimitReq) 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 SpendLimit

	// no validation rules for Region

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SetSpendLimitReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for SpendLimit

	// no validation rules for Region

	// no validation rules for ProjectId

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PredictSpendLimitReqValidationError{}

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

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

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

func (m *PredictClusterSpendLimitReq) 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 SpendLimit

	// no validation rules for Region

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PredictClusterSpendLimitReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for SpendLimit

	// no validation rules for FreeCredit

	// no validation rules for MaxRequestUnits

	// no validation rules for MaxColumnStorage

	// no validation rules for MaxRowStorage

	// no validation rules for FreeRequestUnits

	// no validation rules for FreeColumnStorage

	// no validation rules for FreeRowStorage

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PredictSpendLimitRespValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ClusterId

	// no validation rules for SpendLimit

	// no validation rules for FreeCredit

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSpendLimitRespValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Total

	// no validation rules for FreeCreditMaxCount

	// no validation rules for HasFreeCreditQuota

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetAllSpendLimitsRespValidationError{}

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

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

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

func (m *GetSpendLimitDetailsReq) 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 GetSpendLimitDetailsReqMultiError(errors)
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSpendLimitDetailsReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RequestUnit

	// no validation rules for RowStorage

	// no validation rules for ColumnStorage

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ResourceUsagesValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RequestUnit

	// no validation rules for RowStorage

	// no validation rules for ColumnStorage

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = MoneySpentsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ClusterId

	// no validation rules for SpendLimit

	// no validation rules for FreeCredit

	// no validation rules for SpentTotal

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSpendLimitDetailsRespValidationError{}

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

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

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

func (m *GetResourceLimitModeReq) 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 GetResourceLimitModeReqMultiError(errors)
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetResourceLimitModeReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ClusterId

	// no validation rules for RuMode

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetResourceLimitModeRespValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Region

	// no validation rules for CloudProvider

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetPricingDetailsReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Region

	// no validation rules for RequestUnits

	// no validation rules for RowBasedStorage

	// no validation rules for ColumnStorage

	// no validation rules for CloudProvider

	// no validation rules for RequestCapacityUnits

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetPricingDetailsRespValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for OrgId

	// no validation rules for Preview

	// no validation rules for SkipDownloadS3

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ExpensiveSqlEmailReqValidationError{}

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

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

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

func (m *ExpensiveSqlEmailResp) 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, ExpensiveSqlEmailRespValidationError{
					field:  "BaseResp",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ExpensiveSqlEmailRespValidationError{
					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 ExpensiveSqlEmailRespValidationError{
				field:  "BaseResp",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ExpensiveSqlEmailRespValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for CloudProvider

	// no validation rules for Region

	// no validation rules for Rcu

	// no validation rules for ServicePlan

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PredictCostReqValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for CloudProvider

	// no validation rules for Region

	// no validation rules for Rcu

	// no validation rules for RcuCostHourly

	// no validation rules for RcuCostMonthly

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = PredictCostRespValidationError{}

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

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

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

func (m *DeleteSpendLimitReq) 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 DeleteSpendLimitReqMultiError(errors)
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteSpendLimitReqValidationError{}

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