grpc_service.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: pkg/apis/inference/grpc_service.proto

package inference

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerLiveRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Live

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerLiveResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerReadyRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Ready

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerReadyResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelReadyRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Ready

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelReadyResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerMetadataRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ServerMetadataResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelMetadataRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Platform

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelMetadataResponseValidationError{}

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

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

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

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

	var errors []error

	switch v := m.ParameterChoice.(type) {
	case *InferParameter_BoolParam:
		if v == nil {
			err := InferParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for BoolParam
	case *InferParameter_Int64Param:
		if v == nil {
			err := InferParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Int64Param
	case *InferParameter_StringParam:
		if v == nil {
			err := InferParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for StringParam
	case *InferParameter_DoubleParam:
		if v == nil {
			err := InferParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for DoubleParam
	case *InferParameter_Uint64Param:
		if v == nil {
			err := InferParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Uint64Param
	default:
		_ = v // ensures v is used
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = InferParameterValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = InferTensorContentsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ModelName

	// no validation rules for ModelVersion

	// no validation rules for Id

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, ModelInferRequestValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, ModelInferRequestValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return ModelInferRequestValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelInferRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ModelName

	// no validation rules for ModelVersion

	// no validation rules for Id

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, ModelInferResponseValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, ModelInferResponseValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return ModelInferResponseValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelInferResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for ErrorMessage

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelStreamInferResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelConfigRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelConfigResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelStatisticsRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Count

	// no validation rules for Ns

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = StatisticDurationValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = InferStatisticsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for BatchSize

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = InferBatchStatisticsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Type

	// no validation rules for Id

	// no validation rules for ByteSize

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = MemoryUsageValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

	// no validation rules for LastInference

	// no validation rules for InferenceCount

	// no validation rules for ExecutionCount

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

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

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

	}

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelStatisticsValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelStatisticsResponseValidationError{}

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

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

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

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

	var errors []error

	switch v := m.ParameterChoice.(type) {
	case *ModelRepositoryParameter_BoolParam:
		if v == nil {
			err := ModelRepositoryParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for BoolParam
	case *ModelRepositoryParameter_Int64Param:
		if v == nil {
			err := ModelRepositoryParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Int64Param
	case *ModelRepositoryParameter_StringParam:
		if v == nil {
			err := ModelRepositoryParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for StringParam
	case *ModelRepositoryParameter_BytesParam:
		if v == nil {
			err := ModelRepositoryParameterValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for BytesParam
	default:
		_ = v // ensures v is used
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelRepositoryParameterValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RepositoryName

	// no validation rules for Ready

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryIndexRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryIndexResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RepositoryName

	// no validation rules for ModelName

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, RepositoryModelLoadRequestValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, RepositoryModelLoadRequestValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return RepositoryModelLoadRequestValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryModelLoadRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryModelLoadResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for RepositoryName

	// no validation rules for ModelName

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, RepositoryModelUnloadRequestValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, RepositoryModelUnloadRequestValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return RepositoryModelUnloadRequestValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryModelUnloadRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryModelUnloadResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryStatusRequestValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetRegions()))
		i := 0
		for key := range m.GetRegions() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetRegions()[key]
			_ = val

			// no validation rules for Regions[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, SystemSharedMemoryStatusResponseValidationError{
							field:  fmt.Sprintf("Regions[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, SystemSharedMemoryStatusResponseValidationError{
							field:  fmt.Sprintf("Regions[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return SystemSharedMemoryStatusResponseValidationError{
						field:  fmt.Sprintf("Regions[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryStatusResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Key

	// no validation rules for Offset

	// no validation rules for ByteSize

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryRegisterRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryRegisterResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryUnregisterRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryUnregisterResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryStatusRequestValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetRegions()))
		i := 0
		for key := range m.GetRegions() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetRegions()[key]
			_ = val

			// no validation rules for Regions[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, CudaSharedMemoryStatusResponseValidationError{
							field:  fmt.Sprintf("Regions[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, CudaSharedMemoryStatusResponseValidationError{
							field:  fmt.Sprintf("Regions[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return CudaSharedMemoryStatusResponseValidationError{
						field:  fmt.Sprintf("Regions[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryStatusResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for RawHandle

	// no validation rules for DeviceId

	// no validation rules for ByteSize

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryRegisterRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryRegisterResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryUnregisterRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryUnregisterResponseValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetSettings()))
		i := 0
		for key := range m.GetSettings() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetSettings()[key]
			_ = val

			// no validation rules for Settings[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, TraceSettingRequestValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, TraceSettingRequestValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return TraceSettingRequestValidationError{
						field:  fmt.Sprintf("Settings[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

	// no validation rules for ModelName

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = TraceSettingRequestValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetSettings()))
		i := 0
		for key := range m.GetSettings() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetSettings()[key]
			_ = val

			// no validation rules for Settings[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, TraceSettingResponseValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, TraceSettingResponseValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return TraceSettingResponseValidationError{
						field:  fmt.Sprintf("Settings[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = TraceSettingResponseValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetSettings()))
		i := 0
		for key := range m.GetSettings() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetSettings()[key]
			_ = val

			// no validation rules for Settings[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, LogSettingsRequestValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, LogSettingsRequestValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return LogSettingsRequestValidationError{
						field:  fmt.Sprintf("Settings[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = LogSettingsRequestValidationError{}

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

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

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

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

	var errors []error

	{
		sorted_keys := make([]string, len(m.GetSettings()))
		i := 0
		for key := range m.GetSettings() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetSettings()[key]
			_ = val

			// no validation rules for Settings[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, LogSettingsResponseValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, LogSettingsResponseValidationError{
							field:  fmt.Sprintf("Settings[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return LogSettingsResponseValidationError{
						field:  fmt.Sprintf("Settings[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = LogSettingsResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Datatype

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelMetadataResponse_TensorMetadataValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Datatype

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, ModelInferRequest_InferInputTensorValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, ModelInferRequest_InferInputTensorValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return ModelInferRequest_InferInputTensorValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelInferRequest_InferInputTensorValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, ModelInferRequest_InferRequestedOutputTensorValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, ModelInferRequest_InferRequestedOutputTensorValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return ModelInferRequest_InferRequestedOutputTensorValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelInferRequest_InferRequestedOutputTensorValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Datatype

	{
		sorted_keys := make([]string, len(m.GetParameters()))
		i := 0
		for key := range m.GetParameters() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetParameters()[key]
			_ = val

			// no validation rules for Parameters[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, ModelInferResponse_InferOutputTensorValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, ModelInferResponse_InferOutputTensorValidationError{
							field:  fmt.Sprintf("Parameters[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return ModelInferResponse_InferOutputTensorValidationError{
						field:  fmt.Sprintf("Parameters[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ModelInferResponse_InferOutputTensorValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Version

	// no validation rules for State

	// no validation rules for Reason

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = RepositoryIndexResponse_ModelIndexValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for Key

	// no validation rules for Offset

	// no validation rules for ByteSize

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SystemSharedMemoryStatusResponse_RegionStatusValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Name

	// no validation rules for DeviceId

	// no validation rules for ByteSize

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CudaSharedMemoryStatusResponse_RegionStatusValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

// Key function returns key value.
func (e TraceSettingRequest_SettingValueValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e TraceSettingRequest_SettingValueValidationError) ErrorName() string {
	return "TraceSettingRequest_SettingValueValidationError"
}

// Error satisfies the builtin error interface
func (e TraceSettingRequest_SettingValueValidationError) 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 %sTraceSettingRequest_SettingValue.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TraceSettingRequest_SettingValueValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = TraceSettingRequest_SettingValueValidationError{}

// Validate checks the field values on TraceSettingResponse_SettingValue 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 *TraceSettingResponse_SettingValue) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on TraceSettingResponse_SettingValue
// 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
// TraceSettingResponse_SettingValueMultiError, or nil if none found.
func (m *TraceSettingResponse_SettingValue) ValidateAll() error {
	return m.validate(true)
}

func (m *TraceSettingResponse_SettingValue) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return TraceSettingResponse_SettingValueMultiError(errors)
	}

	return nil
}

// TraceSettingResponse_SettingValueMultiError is an error wrapping multiple
// validation errors returned by
// TraceSettingResponse_SettingValue.ValidateAll() if the designated
// constraints aren't met.
type TraceSettingResponse_SettingValueMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m TraceSettingResponse_SettingValueMultiError) 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 TraceSettingResponse_SettingValueMultiError) AllErrors() []error { return m }

// TraceSettingResponse_SettingValueValidationError is the validation error
// returned by TraceSettingResponse_SettingValue.Validate if the designated
// constraints aren't met.
type TraceSettingResponse_SettingValueValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e TraceSettingResponse_SettingValueValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e TraceSettingResponse_SettingValueValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e TraceSettingResponse_SettingValueValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e TraceSettingResponse_SettingValueValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e TraceSettingResponse_SettingValueValidationError) ErrorName() string {
	return "TraceSettingResponse_SettingValueValidationError"
}

// Error satisfies the builtin error interface
func (e TraceSettingResponse_SettingValueValidationError) 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 %sTraceSettingResponse_SettingValue.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TraceSettingResponse_SettingValueValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = TraceSettingResponse_SettingValueValidationError{}

// Validate checks the field values on LogSettingsRequest_SettingValue 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 *LogSettingsRequest_SettingValue) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LogSettingsRequest_SettingValue 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
// LogSettingsRequest_SettingValueMultiError, or nil if none found.
func (m *LogSettingsRequest_SettingValue) ValidateAll() error {
	return m.validate(true)
}

func (m *LogSettingsRequest_SettingValue) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	switch v := m.ParameterChoice.(type) {
	case *LogSettingsRequest_SettingValue_BoolParam:
		if v == nil {
			err := LogSettingsRequest_SettingValueValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for BoolParam
	case *LogSettingsRequest_SettingValue_Uint32Param:
		if v == nil {
			err := LogSettingsRequest_SettingValueValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Uint32Param
	case *LogSettingsRequest_SettingValue_StringParam:
		if v == nil {
			err := LogSettingsRequest_SettingValueValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for StringParam
	default:
		_ = v // ensures v is used
	}

	if len(errors) > 0 {
		return LogSettingsRequest_SettingValueMultiError(errors)
	}

	return nil
}

// LogSettingsRequest_SettingValueMultiError is an error wrapping multiple
// validation errors returned by LogSettingsRequest_SettingValue.ValidateAll()
// if the designated constraints aren't met.
type LogSettingsRequest_SettingValueMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LogSettingsRequest_SettingValueMultiError) 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 LogSettingsRequest_SettingValueMultiError) AllErrors() []error { return m }

// LogSettingsRequest_SettingValueValidationError is the validation error
// returned by LogSettingsRequest_SettingValue.Validate if the designated
// constraints aren't met.
type LogSettingsRequest_SettingValueValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LogSettingsRequest_SettingValueValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LogSettingsRequest_SettingValueValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LogSettingsRequest_SettingValueValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LogSettingsRequest_SettingValueValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LogSettingsRequest_SettingValueValidationError) ErrorName() string {
	return "LogSettingsRequest_SettingValueValidationError"
}

// Error satisfies the builtin error interface
func (e LogSettingsRequest_SettingValueValidationError) 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 %sLogSettingsRequest_SettingValue.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LogSettingsRequest_SettingValueValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LogSettingsRequest_SettingValueValidationError{}

// Validate checks the field values on LogSettingsResponse_SettingValue 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 *LogSettingsResponse_SettingValue) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LogSettingsResponse_SettingValue 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
// LogSettingsResponse_SettingValueMultiError, or nil if none found.
func (m *LogSettingsResponse_SettingValue) ValidateAll() error {
	return m.validate(true)
}

func (m *LogSettingsResponse_SettingValue) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	switch v := m.ParameterChoice.(type) {
	case *LogSettingsResponse_SettingValue_BoolParam:
		if v == nil {
			err := LogSettingsResponse_SettingValueValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for BoolParam
	case *LogSettingsResponse_SettingValue_Uint32Param:
		if v == nil {
			err := LogSettingsResponse_SettingValueValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for Uint32Param
	case *LogSettingsResponse_SettingValue_StringParam:
		if v == nil {
			err := LogSettingsResponse_SettingValueValidationError{
				field:  "ParameterChoice",
				reason: "oneof value cannot be a typed-nil",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}
		// no validation rules for StringParam
	default:
		_ = v // ensures v is used
	}

	if len(errors) > 0 {
		return LogSettingsResponse_SettingValueMultiError(errors)
	}

	return nil
}

// LogSettingsResponse_SettingValueMultiError is an error wrapping multiple
// validation errors returned by
// LogSettingsResponse_SettingValue.ValidateAll() if the designated
// constraints aren't met.
type LogSettingsResponse_SettingValueMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m LogSettingsResponse_SettingValueMultiError) 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 LogSettingsResponse_SettingValueMultiError) AllErrors() []error { return m }

// LogSettingsResponse_SettingValueValidationError is the validation error
// returned by LogSettingsResponse_SettingValue.Validate if the designated
// constraints aren't met.
type LogSettingsResponse_SettingValueValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e LogSettingsResponse_SettingValueValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e LogSettingsResponse_SettingValueValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e LogSettingsResponse_SettingValueValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e LogSettingsResponse_SettingValueValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e LogSettingsResponse_SettingValueValidationError) ErrorName() string {
	return "LogSettingsResponse_SettingValueValidationError"
}

// Error satisfies the builtin error interface
func (e LogSettingsResponse_SettingValueValidationError) 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 %sLogSettingsResponse_SettingValue.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = LogSettingsResponse_SettingValueValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = LogSettingsResponse_SettingValueValidationError{}