user.pb.validate.go

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

package v1

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListUsersCallValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetUserCallValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateUserCallValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateUserCallValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteUserCallValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Email

	// no validation rules for FirstName

	// no validation rules for LastName

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UserValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListUsersCall_RequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListUsersCall_ResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetUserCall_RequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetUserCall_ResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	if err := m._validateEmail(m.GetEmail()); err != nil {
		err = UpdateUserCall_RequestValidationError{
			field:  "Email",
			reason: "value must be a valid email address",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetFirstName()) < 1 {
		err := UpdateUserCall_RequestValidationError{
			field:  "FirstName",
			reason: "value length must be at least 1 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetLastName()) < 1 {
		err := UpdateUserCall_RequestValidationError{
			field:  "LastName",
			reason: "value length must be at least 1 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *UpdateUserCall_Request) _validateHostname(host string) error {
	s := strings.ToLower(strings.TrimSuffix(host, "."))

	if len(host) > 253 {
		return errors.New("hostname cannot exceed 253 characters")
	}

	for _, part := range strings.Split(s, ".") {
		if l := len(part); l == 0 || l > 63 {
			return errors.New("hostname part must be non-empty and cannot exceed 63 characters")
		}

		if part[0] == '-' {
			return errors.New("hostname parts cannot begin with hyphens")
		}

		if part[len(part)-1] == '-' {
			return errors.New("hostname parts cannot end with hyphens")
		}

		for _, r := range part {
			if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
				return fmt.Errorf("hostname parts can only contain alphanumeric characters or hyphens, got %q", string(r))
			}
		}
	}

	return nil
}

func (m *UpdateUserCall_Request) _validateEmail(addr string) error {
	a, err := mail.ParseAddress(addr)
	if err != nil {
		return err
	}
	addr = a.Address

	if len(addr) > 254 {
		return errors.New("email addresses cannot exceed 254 characters")
	}

	parts := strings.SplitN(addr, "@", 2)

	if len(parts[0]) > 64 {
		return errors.New("email address local phrase cannot exceed 64 characters")
	}

	return m._validateHostname(parts[1])
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateUserCall_RequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateUserCall_ResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Email

	if utf8.RuneCountInString(m.GetFirstName()) < 1 {
		err := CreateUserCall_RequestValidationError{
			field:  "FirstName",
			reason: "value length must be at least 1 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if utf8.RuneCountInString(m.GetLastName()) < 1 {
		err := CreateUserCall_RequestValidationError{
			field:  "LastName",
			reason: "value length must be at least 1 runes",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Password

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateUserCall_RequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateUserCall_ResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteUserCall_RequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteUserCall_ResponseValidationError{}

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