package v3alpha

import (
	"bytes"
	"errors"
	"fmt"
	"net"
	"net/mail"
	"net/url"
	"regexp"
	"sort"
	"strings"
	"time"
	"unicode/utf8"

	"google.golang.org/protobuf/types/known/anypb"

	v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
)

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

	_ = v3.ApiVersion(0)
)

func (m *TraServiceConfig) Validate() error {
	return m.validate(false)
}

func (m *TraServiceConfig) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	if m.GetGrpcService() == nil {
		err := TraServiceConfigValidationError{
			field:  "GrpcService",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if _, ok := v3.ApiVersion_name[int32(m.GetTransportApiVersion())]; !ok {
		err := TraServiceConfigValidationError{
			field:  "TransportApiVersion",
			reason: "value must be one of the defined enum values",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

type TraServiceConfigMultiError []error

func (m TraServiceConfigMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m TraServiceConfigMultiError) AllErrors() []error { return m }

type TraServiceConfigValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e TraServiceConfigValidationError) Field() string { return e.field }

func (e TraServiceConfigValidationError) Reason() string { return e.reason }

func (e TraServiceConfigValidationError) Cause() error { return e.cause }

func (e TraServiceConfigValidationError) Key() bool { return e.key }

func (e TraServiceConfigValidationError) ErrorName() string { return "TraServiceConfigValidationError" }

func (e TraServiceConfigValidationError) 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 %sTraServiceConfig.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TraServiceConfigValidationError{}

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

func (m *TraServiceRequest) Validate() error {
	return m.validate(false)
}

func (m *TraServiceRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	switch m.Request.(type) {

	case *TraServiceRequest_CreateRequest:

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

	case *TraServiceRequest_UpdateRequest:

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

	case *TraServiceRequest_RetrieveRequest:

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

	case *TraServiceRequest_DeleteRequest:

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

	case *TraServiceRequest_SubscribeRequest:

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

	}

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

type TraServiceRequestMultiError []error

func (m TraServiceRequestMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m TraServiceRequestMultiError) AllErrors() []error { return m }

type TraServiceRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e TraServiceRequestValidationError) Field() string { return e.field }

func (e TraServiceRequestValidationError) Reason() string { return e.reason }

func (e TraServiceRequestValidationError) Cause() error { return e.cause }

func (e TraServiceRequestValidationError) Key() bool { return e.key }

func (e TraServiceRequestValidationError) ErrorName() string {
	return "TraServiceRequestValidationError"
}

func (e TraServiceRequestValidationError) 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 %sTraServiceRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TraServiceRequestValidationError{}

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

func (m *TraServiceResponse) Validate() error {
	return m.validate(false)
}

func (m *TraServiceResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	switch m.Response.(type) {

	case *TraServiceResponse_CreateResponse:

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

	case *TraServiceResponse_UpdateResponse:

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

	case *TraServiceResponse_RetrieveResponse:

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

	case *TraServiceResponse_DeleteResponse:

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

	case *TraServiceResponse_SubscribeResponse:

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

	}

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

type TraServiceResponseMultiError []error

func (m TraServiceResponseMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m TraServiceResponseMultiError) AllErrors() []error { return m }

type TraServiceResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e TraServiceResponseValidationError) Field() string { return e.field }

func (e TraServiceResponseValidationError) Reason() string { return e.reason }

func (e TraServiceResponseValidationError) Cause() error { return e.cause }

func (e TraServiceResponseValidationError) Key() bool { return e.key }

func (e TraServiceResponseValidationError) ErrorName() string {
	return "TraServiceResponseValidationError"
}

func (e TraServiceResponseValidationError) 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 %sTraServiceResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TraServiceResponseValidationError{}

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

func (m *CreateRequest) Validate() error {
	return m.validate(false)
}

func (m *CreateRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type CreateRequestMultiError []error

func (m CreateRequestMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m CreateRequestMultiError) AllErrors() []error { return m }

type CreateRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e CreateRequestValidationError) Field() string { return e.field }

func (e CreateRequestValidationError) Reason() string { return e.reason }

func (e CreateRequestValidationError) Cause() error { return e.cause }

func (e CreateRequestValidationError) Key() bool { return e.key }

func (e CreateRequestValidationError) ErrorName() string { return "CreateRequestValidationError" }

func (e CreateRequestValidationError) 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 %sCreateRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CreateRequestValidationError{}

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

func (m *CreateResponse) Validate() error {
	return m.validate(false)
}

func (m *CreateResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type CreateResponseMultiError []error

func (m CreateResponseMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m CreateResponseMultiError) AllErrors() []error { return m }

type CreateResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e CreateResponseValidationError) Field() string { return e.field }

func (e CreateResponseValidationError) Reason() string { return e.reason }

func (e CreateResponseValidationError) Cause() error { return e.cause }

func (e CreateResponseValidationError) Key() bool { return e.key }

func (e CreateResponseValidationError) ErrorName() string { return "CreateResponseValidationError" }

func (e CreateResponseValidationError) 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 %sCreateResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CreateResponseValidationError{}

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

func (m *UpdateRequest) Validate() error {
	return m.validate(false)
}

func (m *UpdateRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type UpdateRequestMultiError []error

func (m UpdateRequestMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m UpdateRequestMultiError) AllErrors() []error { return m }

type UpdateRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e UpdateRequestValidationError) Field() string { return e.field }

func (e UpdateRequestValidationError) Reason() string { return e.reason }

func (e UpdateRequestValidationError) Cause() error { return e.cause }

func (e UpdateRequestValidationError) Key() bool { return e.key }

func (e UpdateRequestValidationError) ErrorName() string { return "UpdateRequestValidationError" }

func (e UpdateRequestValidationError) 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 %sUpdateRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateRequestValidationError{}

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

func (m *UpdateResponse) Validate() error {
	return m.validate(false)
}

func (m *UpdateResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type UpdateResponseMultiError []error

func (m UpdateResponseMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m UpdateResponseMultiError) AllErrors() []error { return m }

type UpdateResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e UpdateResponseValidationError) Field() string { return e.field }

func (e UpdateResponseValidationError) Reason() string { return e.reason }

func (e UpdateResponseValidationError) Cause() error { return e.cause }

func (e UpdateResponseValidationError) Key() bool { return e.key }

func (e UpdateResponseValidationError) ErrorName() string { return "UpdateResponseValidationError" }

func (e UpdateResponseValidationError) 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 %sUpdateResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateResponseValidationError{}

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

func (m *RetrieveRequest) Validate() error {
	return m.validate(false)
}

func (m *RetrieveRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type RetrieveRequestMultiError []error

func (m RetrieveRequestMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m RetrieveRequestMultiError) AllErrors() []error { return m }

type RetrieveRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e RetrieveRequestValidationError) Field() string { return e.field }

func (e RetrieveRequestValidationError) Reason() string { return e.reason }

func (e RetrieveRequestValidationError) Cause() error { return e.cause }

func (e RetrieveRequestValidationError) Key() bool { return e.key }

func (e RetrieveRequestValidationError) ErrorName() string { return "RetrieveRequestValidationError" }

func (e RetrieveRequestValidationError) 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 %sRetrieveRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RetrieveRequestValidationError{}

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

func (m *RetrieveResponse) Validate() error {
	return m.validate(false)
}

func (m *RetrieveResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type RetrieveResponseMultiError []error

func (m RetrieveResponseMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m RetrieveResponseMultiError) AllErrors() []error { return m }

type RetrieveResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e RetrieveResponseValidationError) Field() string { return e.field }

func (e RetrieveResponseValidationError) Reason() string { return e.reason }

func (e RetrieveResponseValidationError) Cause() error { return e.cause }

func (e RetrieveResponseValidationError) Key() bool { return e.key }

func (e RetrieveResponseValidationError) ErrorName() string { return "RetrieveResponseValidationError" }

func (e RetrieveResponseValidationError) 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 %sRetrieveResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RetrieveResponseValidationError{}

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

func (m *DeleteRequest) Validate() error {
	return m.validate(false)
}

func (m *DeleteRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type DeleteRequestMultiError []error

func (m DeleteRequestMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m DeleteRequestMultiError) AllErrors() []error { return m }

type DeleteRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e DeleteRequestValidationError) Field() string { return e.field }

func (e DeleteRequestValidationError) Reason() string { return e.reason }

func (e DeleteRequestValidationError) Cause() error { return e.cause }

func (e DeleteRequestValidationError) Key() bool { return e.key }

func (e DeleteRequestValidationError) ErrorName() string { return "DeleteRequestValidationError" }

func (e DeleteRequestValidationError) 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 %sDeleteRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteRequestValidationError{}

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

func (m *DeleteResponse) Validate() error {
	return m.validate(false)
}

func (m *DeleteResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type DeleteResponseMultiError []error

func (m DeleteResponseMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m DeleteResponseMultiError) AllErrors() []error { return m }

type DeleteResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e DeleteResponseValidationError) Field() string { return e.field }

func (e DeleteResponseValidationError) Reason() string { return e.reason }

func (e DeleteResponseValidationError) Cause() error { return e.cause }

func (e DeleteResponseValidationError) Key() bool { return e.key }

func (e DeleteResponseValidationError) ErrorName() string { return "DeleteResponseValidationError" }

func (e DeleteResponseValidationError) 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 %sDeleteResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteResponseValidationError{}

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

func (m *SubscribeRequest) Validate() error {
	return m.validate(false)
}

func (m *SubscribeRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type SubscribeRequestMultiError []error

func (m SubscribeRequestMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m SubscribeRequestMultiError) AllErrors() []error { return m }

type SubscribeRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e SubscribeRequestValidationError) Field() string { return e.field }

func (e SubscribeRequestValidationError) Reason() string { return e.reason }

func (e SubscribeRequestValidationError) Cause() error { return e.cause }

func (e SubscribeRequestValidationError) Key() bool { return e.key }

func (e SubscribeRequestValidationError) ErrorName() string { return "SubscribeRequestValidationError" }

func (e SubscribeRequestValidationError) 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 %sSubscribeRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SubscribeRequestValidationError{}

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

func (m *SubscribeResponse) Validate() error {
	return m.validate(false)
}

func (m *SubscribeResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

type SubscribeResponseMultiError []error

func (m SubscribeResponseMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

func (m SubscribeResponseMultiError) AllErrors() []error { return m }

type SubscribeResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

func (e SubscribeResponseValidationError) Field() string { return e.field }

func (e SubscribeResponseValidationError) Reason() string { return e.reason }

func (e SubscribeResponseValidationError) Cause() error { return e.cause }

func (e SubscribeResponseValidationError) Key() bool { return e.key }

func (e SubscribeResponseValidationError) ErrorName() string {
	return "SubscribeResponseValidationError"
}

func (e SubscribeResponseValidationError) 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 %sSubscribeResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SubscribeResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SubscribeResponseValidationError{}
// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: contrib/envoy/extensions/filters/network/sip_proxy/tra/v3alpha/tra.proto

package v3alpha

import (
	"bytes"
	"errors"
	"fmt"
	"net"
	"net/mail"
	"net/url"
	"regexp"
	"sort"
	"strings"
	"time"
	"unicode/utf8"

	"google.golang.org/protobuf/types/known/anypb"

	v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
)

// 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

	_ = v3.ApiVersion(0)
)

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

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

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

	var errors []error

	if m.GetGrpcService() == nil {
		err := TraServiceConfigValidationError{
			field:  "GrpcService",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	if _, ok := v3.ApiVersion_name[int32(m.GetTransportApiVersion())]; !ok {
		err := TraServiceConfigValidationError{
			field:  "TransportApiVersion",
			reason: "value must be one of the defined enum values",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

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

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

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

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

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

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

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

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

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

var _ error = TraServiceConfigValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Type

	switch m.Request.(type) {

	case *TraServiceRequest_CreateRequest:

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

	case *TraServiceRequest_UpdateRequest:

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

	case *TraServiceRequest_RetrieveRequest:

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

	case *TraServiceRequest_DeleteRequest:

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

	case *TraServiceRequest_SubscribeRequest:

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

	}

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

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

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

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

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

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

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

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

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

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

var _ error = TraServiceRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Type

	// no validation rules for Ret

	// no validation rules for Reason

	switch m.Response.(type) {

	case *TraServiceResponse_CreateResponse:

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

	case *TraServiceResponse_UpdateResponse:

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

	case *TraServiceResponse_RetrieveResponse:

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

	case *TraServiceResponse_DeleteResponse:

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

	case *TraServiceResponse_SubscribeResponse:

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

	}

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

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

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

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

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

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

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

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

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

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

var _ error = TraServiceResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Data

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

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

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

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

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

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

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

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

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

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

var _ error = CreateRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = CreateResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Data

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

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

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

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

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

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

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

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

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

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

var _ error = UpdateRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = UpdateResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Key

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

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

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

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

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

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

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

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

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

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

var _ error = RetrieveRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Data

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

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

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

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

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

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

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

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

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

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

var _ error = RetrieveResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Key

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = DeleteResponseValidationError{}

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

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

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

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

	var errors []error

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

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

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

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

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

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

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

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

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

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

var _ error = SubscribeRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Data

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

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

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

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

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

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

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

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

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

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

var _ error = SubscribeResponseValidationError{}

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