stencil.pb.validate.go

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

package stencilv1beta1

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Format

	// no validation rules for Compatibility

	// no validation rules for Description

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

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

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

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

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

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

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

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

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

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

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

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

var _ error = NamespaceValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Format

	// no validation rules for Authority

	// no validation rules for Compatibility

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

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

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

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

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

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

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

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

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

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

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

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

var _ error = SchemaValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = ListNamespacesRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

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

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

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

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

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

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

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

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

var _ error = ListNamespacesResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

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

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

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

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

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

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

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

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

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

var _ error = GetNamespaceRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

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

var _ error = GetNamespaceResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Format

	// no validation rules for Compatibility

	// no validation rules for Description

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

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

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

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

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

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

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

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

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

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

var _ error = CreateNamespaceRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

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

var _ error = CreateNamespaceResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Format

	// no validation rules for Compatibility

	// no validation rules for Description

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

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

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

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

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

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

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

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

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

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

var _ error = UpdateNamespaceRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

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

var _ error = UpdateNamespaceResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteNamespaceRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Message

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteNamespaceResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

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

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

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

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

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

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

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

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

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

var _ error = ListSchemasRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

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

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

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

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

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

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

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

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

var _ error = ListSchemasResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

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

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

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

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

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

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

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

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

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

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

var _ error = GetLatestSchemaRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Data

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

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

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

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

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

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

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

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

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

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

var _ error = GetLatestSchemaResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for Data

	// no validation rules for Format

	// no validation rules for Compatibility

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

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

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

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

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

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

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

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

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

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

var _ error = CreateSchemaRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Version

	// no validation rules for Id

	// no validation rules for Location

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

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

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

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

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

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

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

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

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

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

var _ error = CreateSchemaResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for Data

	// no validation rules for Compatibility

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

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

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

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

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

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

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

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

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

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

var _ error = CheckCompatibilityRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = CheckCompatibilityResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

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

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

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

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

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

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

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

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

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

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

var _ error = GetSchemaMetadataRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Format

	// no validation rules for Compatibility

	// no validation rules for Authority

	// no validation rules for Name

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

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

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

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

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

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

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

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

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

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

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

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

var _ error = GetSchemaMetadataResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for Compatibility

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

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

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

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

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

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

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

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

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

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

var _ error = UpdateSchemaMetadataRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Format

	// no validation rules for Compatibility

	// no validation rules for Authority

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

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

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

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

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

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

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

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

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

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

var _ error = UpdateSchemaMetadataResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteSchemaRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Message

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteSchemaResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

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

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

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

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

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

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

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

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

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

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

var _ error = ListVersionsRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = ListVersionsResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for VersionId

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

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

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

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

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

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

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

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

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

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

var _ error = GetSchemaRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Data

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

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

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

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

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

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

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

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

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

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

var _ error = GetSchemaResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for VersionId

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteVersionRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Message

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteVersionResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for Query

	switch m.Version.(type) {

	case *SearchRequest_History:
		// no validation rules for History

	case *SearchRequest_VersionId:
		// no validation rules for VersionId

	}

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

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

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

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

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

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

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

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

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

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

var _ error = SearchRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SearchResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for NamespaceId

	// no validation rules for SchemaId

	// no validation rules for VersionId

	// no validation rules for Path

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

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

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

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

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

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

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

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

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

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

var _ error = SearchHitsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Total

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

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

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

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

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

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

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

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

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

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

var _ error = SearchMetaValidationError{}

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