project.pb.validate.go

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

package apiv1

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
)

// define the regex for a UUID once up-front
var _project_uuidPattern = regexp.MustCompile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")

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

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

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

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Name

	// no validation rules for Description

	// no validation rules for Tenant

	if all {
		switch v := interface{}(m.GetCreatedAt()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ProjectValidationError{
					field:  "CreatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ProjectValidationError{
					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 ProjectValidationError{
				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, ProjectValidationError{
					field:  "UpdatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ProjectValidationError{
					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 ProjectValidationError{
				field:  "UpdatedAt",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Role

	// no validation rules for InheritedMembership

	if all {
		switch v := interface{}(m.GetCreatedAt()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ProjectMemberValidationError{
					field:  "CreatedAt",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ProjectMemberValidationError{
					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 ProjectMemberValidationError{
				field:  "CreatedAt",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectMemberValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Secret

	// no validation rules for Project

	// no validation rules for Role

	// no validation rules for Joined

	// no validation rules for ProjectName

	// no validation rules for Tenant

	// no validation rules for TenantName

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectInviteValidationError{}

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

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

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

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

	var errors []error

	if m.Name != nil {

		if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 128 {
			err := ProjectServiceListRequestValidationError{
				field:  "Name",
				reason: "value length must be between 2 and 128 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Tenant != nil {

		if l := utf8.RuneCountInString(m.GetTenant()); l < 2 || l > 128 {
			err := ProjectServiceListRequestValidationError{
				field:  "Tenant",
				reason: "value length must be between 2 and 128 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceListRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceListResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceGetRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *ProjectServiceGetRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceGetRequestValidationError{}

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

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

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

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

	var errors []error

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

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceGetResponseValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetLogin()); l < 2 || l > 128 {
		err := ProjectServiceCreateRequestValidationError{
			field:  "Login",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 64 {
		err := ProjectServiceCreateRequestValidationError{
			field:  "Name",
			reason: "value length must be between 2 and 64 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetDescription()); l < 2 || l > 512 {
		err := ProjectServiceCreateRequestValidationError{
			field:  "Description",
			reason: "value length must be between 2 and 512 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceCreateRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceCreateResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceDeleteRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *ProjectServiceDeleteRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceDeleteRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceDeleteResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceUpdateRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.Name != nil {

		if l := utf8.RuneCountInString(m.GetName()); l < 2 || l > 64 {
			err := ProjectServiceUpdateRequestValidationError{
				field:  "Name",
				reason: "value length must be between 2 and 64 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Description != nil {

		if l := utf8.RuneCountInString(m.GetDescription()); l < 2 || l > 512 {
			err := ProjectServiceUpdateRequestValidationError{
				field:  "Description",
				reason: "value length must be between 2 and 512 runes, inclusive",
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

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

	return nil
}

func (m *ProjectServiceUpdateRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceUpdateRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceUpdateResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceInviteRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Role

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

	return nil
}

func (m *ProjectServiceInviteRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceInvitesListRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *ProjectServiceInvitesListRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInvitesListRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInvitesListResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Secret

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteGetRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteGetResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceRemoveMemberRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for MemberId

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

	return nil
}

func (m *ProjectServiceRemoveMemberRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceRemoveMemberRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceRemoveMemberResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceUpdateMemberRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for MemberId

	// no validation rules for Role

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

	return nil
}

func (m *ProjectServiceUpdateMemberRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceUpdateMemberRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceUpdateMemberResponseValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Secret

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteAcceptRequestValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Project

	// no validation rules for ProjectName

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteAcceptResponseValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetProject()); err != nil {
		err = ProjectServiceInviteDeleteRequestValidationError{
			field:  "Project",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	// no validation rules for Secret

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

	return nil
}

func (m *ProjectServiceInviteDeleteRequest) _validateUuid(uuid string) error {
	if matched := _project_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteDeleteRequestValidationError{}

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

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

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

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

	var errors []error

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

	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ProjectServiceInviteDeleteResponseValidationError{}

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