// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: user/api/account/v1/account.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"

	v1 "github.com/go-saas/kit/user/api/user/v1"
)

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

	_ = v1.Gender(0)
)

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetProfileRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Gender

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

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

	}

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

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

	}

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

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

	if m.Username != nil {
		// no validation rules for Username
	}

	if m.Name != nil {
		// no validation rules for Name
	}

	if m.Phone != nil {
		// no validation rules for Phone
	}

	if m.Email != nil {
		// no validation rules for Email
	}

	if m.Birthday != nil {

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetProfileResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Gender

	if m.Username != nil {
		// no validation rules for Username
	}

	if m.Name != nil {
		// no validation rules for Name
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateProfileRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateProfileResponseValidationError{}

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

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

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

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

	var errors []error

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSettingsRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SettingsFilterValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetSettingsResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateSettingsRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateSettingsResponseValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetAddressesRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetAddressesReplyValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Phone

	// no validation rules for Usage

	// no validation rules for Prefer

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UserAddressValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Phone

	// no validation rules for Usage

	// no validation rules for Prefer

	if m.GetAddress() == nil {
		err := CreateAddressesRequestValidationError{
			field:  "Address",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateAddressesRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateAddressReplyValidationError{}

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

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

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

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

	var errors []error

	if m.GetAddress() == nil {
		err := UpdateAddressesRequestValidationError{
			field:  "Address",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateAddressesRequestValidationError{}

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

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

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

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

	var errors []error

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

	// no validation rules for Phone

	// no validation rules for Usage

	// no validation rules for Prefer

	if m.GetAddress() == nil {
		err := UpdateAddressValidationError{
			field:  "Address",
			reason: "value is required",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateAddressValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateAddressesReplyValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteAddressRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = DeleteAddressesReplyValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for UserId

	// no validation rules for TenantId

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

	// no validation rules for IsHost

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UserTenantValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Key

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SettingsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Key

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

	// no validation rules for Reset_

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateSettingsValidationError{}

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