namespace.pb.validate.go

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

package namespace

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

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

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

	var errors []error

	if len(m.GetNamespace()) < 1 {
		err := NamespaceCreateRequestValidationError{
			field:  "Namespace",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return NamespaceCreateRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceCreateRequestValidationError{}

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

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

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

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

	var errors []error

	if m.GetNamespaceId() <= 0 {
		err := NamespaceShowRequestValidationError{
			field:  "NamespaceId",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return NamespaceShowRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceShowRequestValidationError{}

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

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

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

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

	var errors []error

	if m.GetNamespaceId() <= 0 {
		err := NamespaceDeleteRequestValidationError{
			field:  "NamespaceId",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return NamespaceDeleteRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceDeleteRequestValidationError{}

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

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

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

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

	var errors []error

	if len(m.GetName()) < 1 {
		err := NamespaceIsExistsRequestValidationError{
			field:  "Name",
			reason: "value length must be at least 1 bytes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return NamespaceIsExistsRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceIsExistsRequestValidationError{}

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

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

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

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

	var errors []error

	if m.GetNamespaceId() <= 0 {
		err := NamespaceCpuMemoryRequestValidationError{
			field:  "NamespaceId",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return NamespaceCpuMemoryRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceCpuMemoryRequestValidationError{}

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

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

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

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

	var errors []error

	if m.GetNamespaceId() <= 0 {
		err := NamespaceServiceEndpointsRequestValidationError{
			field:  "NamespaceId",
			reason: "value must be greater than 0",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for ProjectName

	if len(errors) > 0 {
		return NamespaceServiceEndpointsRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceServiceEndpointsRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Name

	// no validation rules for Status

	if len(errors) > 0 {
		return NamespaceSimpleProjectMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceSimpleProjectValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Name

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

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

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

	}

	if len(errors) > 0 {
		return NamespaceItemMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceItemValidationError{}

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

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

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

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

	var errors []error

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

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

	}

	if len(errors) > 0 {
		return NamespaceAllResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceAllResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Name

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return NamespaceCreateResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceCreateResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Name

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

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

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

	}

	if len(errors) > 0 {
		return NamespaceShowResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceShowResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Cpu

	// no validation rules for Memory

	if len(errors) > 0 {
		return NamespaceCpuMemoryResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceCpuMemoryResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Url

	// no validation rules for PortName

	if len(errors) > 0 {
		return NamespaceServiceEndpointMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceServiceEndpointValidationError{}

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

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

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

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

	var errors []error

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

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

	}

	if len(errors) > 0 {
		return NamespaceServiceEndpointsResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceServiceEndpointsResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Exists

	// no validation rules for Id

	if len(errors) > 0 {
		return NamespaceIsExistsResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceIsExistsResponseValidationError{}

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

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

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

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

	var errors []error

	if len(errors) > 0 {
		return NamespaceAllRequestMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceAllRequestValidationError{}

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

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

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

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

	var errors []error

	if len(errors) > 0 {
		return NamespaceDeleteResponseMultiError(errors)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = NamespaceDeleteResponseValidationError{}

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