policy.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: interservice/authz/policy.proto

package authz

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

	"github.com/golang/protobuf/ptypes"
)

// 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)
	_ = ptypes.DynamicAny{}
)

// define the regex for a UUID once up-front
var _policy_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 Policy with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *Policy) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Name

	// no validation rules for Id

	// no validation rules for Type

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

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return PolicyValidationError{
					field:  fmt.Sprintf("Statements[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = PolicyValidationError{}

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

// Validate checks the field values on Role with the rules defined in the proto
// definition for this message. If any rules are violated, an error is returned.
func (m *Role) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Name

	// no validation rules for Id

	// no validation rules for Type

	return nil
}

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

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

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

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

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

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

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

var _ error = RoleValidationError{}

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

// Validate checks the field values on CreatePolicyReq with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *CreatePolicyReq) Validate() error {
	if m == nil {
		return nil
	}

	if !_CreatePolicyReq_Id_Pattern.MatchString(m.GetId()) {
		return CreatePolicyReqValidationError{
			field:  "Id",
			reason: "value does not match regex pattern \"^[a-z0-9-_]{1,64}$\"",
		}
	}

	// no validation rules for Name

	_CreatePolicyReq_Members_Unique := make(map[string]struct{}, len(m.GetMembers()))

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

		if _, exists := _CreatePolicyReq_Members_Unique[item]; exists {
			return CreatePolicyReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_CreatePolicyReq_Members_Unique[item] = struct{}{}
		}

		if !_CreatePolicyReq_Members_Pattern.MatchString(item) {
			return CreatePolicyReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "value does not match regex pattern \"^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$\"",
			}
		}

	}

	if len(m.GetStatements()) < 1 {
		return CreatePolicyReqValidationError{
			field:  "Statements",
			reason: "value must contain at least 1 item(s)",
		}
	}

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

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return CreatePolicyReqValidationError{
					field:  fmt.Sprintf("Statements[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	_CreatePolicyReq_Projects_Unique := make(map[string]struct{}, len(m.GetProjects()))

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

		if _, exists := _CreatePolicyReq_Projects_Unique[item]; exists {
			return CreatePolicyReqValidationError{
				field:  fmt.Sprintf("Projects[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_CreatePolicyReq_Projects_Unique[item] = struct{}{}
		}

		// no validation rules for Projects[idx]
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = CreatePolicyReqValidationError{}

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

var _CreatePolicyReq_Id_Pattern = regexp.MustCompile("^[a-z0-9-_]{1,64}$")

var _CreatePolicyReq_Members_Pattern = regexp.MustCompile("^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$")

// Validate checks the field values on DeletePolicyReq with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *DeletePolicyReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = DeletePolicyReqValidationError{}

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

// Validate checks the field values on DeletePolicyResp with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *DeletePolicyResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = DeletePolicyRespValidationError{}

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

// Validate checks the field values on Statement with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *Statement) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Effect

	_Statement_Resources_Unique := make(map[string]struct{}, len(m.GetResources()))

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

		if _, exists := _Statement_Resources_Unique[item]; exists {
			return StatementValidationError{
				field:  fmt.Sprintf("Resources[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_Statement_Resources_Unique[item] = struct{}{}
		}

		if !_Statement_Resources_Pattern.MatchString(item) {
			return StatementValidationError{
				field:  fmt.Sprintf("Resources[%v]", idx),
				reason: "value does not match regex pattern \"^[a-z][^:*]*(?::[^:*]+)*(?::[*])?$|^[*]$\"",
			}
		}

	}

	_Statement_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _Statement_Actions_Unique[item]; exists {
			return StatementValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_Statement_Actions_Unique[item] = struct{}{}
		}

		if !_Statement_Actions_Pattern.MatchString(item) {
			return StatementValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value does not match regex pattern \"^[*]$|^[*]:[a-z][-a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[*]$|^[a-z][a-zA-Z]*:[*]:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[*]$\"",
			}
		}

	}

	if !_Statement_Role_Pattern.MatchString(m.GetRole()) {
		return StatementValidationError{
			field:  "Role",
			reason: "value does not match regex pattern \"^$|^[a-z0-9-_]{1,64}$\"",
		}
	}

	_Statement_Projects_Unique := make(map[string]struct{}, len(m.GetProjects()))

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

		if _, exists := _Statement_Projects_Unique[item]; exists {
			return StatementValidationError{
				field:  fmt.Sprintf("Projects[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_Statement_Projects_Unique[item] = struct{}{}
		}

		// no validation rules for Projects[idx]
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = StatementValidationError{}

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

var _Statement_Resources_Pattern = regexp.MustCompile("^[a-z][^:*]*(?::[^:*]+)*(?::[*])?$|^[*]$")

var _Statement_Actions_Pattern = regexp.MustCompile("^[*]$|^[*]:[a-z][-a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[*]$|^[a-z][a-zA-Z]*:[*]:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[*]$")

var _Statement_Role_Pattern = regexp.MustCompile("^$|^[a-z0-9-_]{1,64}$")

// Validate checks the field values on ListPoliciesReq with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *ListPoliciesReq) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListPoliciesReqValidationError{}

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

// Validate checks the field values on ListPoliciesResp with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *ListPoliciesResp) Validate() error {
	if m == nil {
		return nil
	}

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

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListPoliciesRespValidationError{
					field:  fmt.Sprintf("Policies[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListPoliciesRespValidationError{}

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

// Validate checks the field values on GetPolicyReq with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *GetPolicyReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = GetPolicyReqValidationError{}

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

// Validate checks the field values on UpdatePolicyReq with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *UpdatePolicyReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	_UpdatePolicyReq_Members_Unique := make(map[string]struct{}, len(m.GetMembers()))

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

		if _, exists := _UpdatePolicyReq_Members_Unique[item]; exists {
			return UpdatePolicyReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_UpdatePolicyReq_Members_Unique[item] = struct{}{}
		}

		if !_UpdatePolicyReq_Members_Pattern.MatchString(item) {
			return UpdatePolicyReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "value does not match regex pattern \"^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$\"",
			}
		}

	}

	if len(m.GetStatements()) < 1 {
		return UpdatePolicyReqValidationError{
			field:  "Statements",
			reason: "value must contain at least 1 item(s)",
		}
	}

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

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdatePolicyReqValidationError{
					field:  fmt.Sprintf("Statements[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Name

	_UpdatePolicyReq_Projects_Unique := make(map[string]struct{}, len(m.GetProjects()))

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

		if _, exists := _UpdatePolicyReq_Projects_Unique[item]; exists {
			return UpdatePolicyReqValidationError{
				field:  fmt.Sprintf("Projects[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_UpdatePolicyReq_Projects_Unique[item] = struct{}{}
		}

		// no validation rules for Projects[idx]
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = UpdatePolicyReqValidationError{}

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

var _UpdatePolicyReq_Members_Pattern = regexp.MustCompile("^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$")

// Validate checks the field values on ReplacePolicyMembersReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *ReplacePolicyMembersReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	_ReplacePolicyMembersReq_Members_Unique := make(map[string]struct{}, len(m.GetMembers()))

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

		if _, exists := _ReplacePolicyMembersReq_Members_Unique[item]; exists {
			return ReplacePolicyMembersReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_ReplacePolicyMembersReq_Members_Unique[item] = struct{}{}
		}

		if !_ReplacePolicyMembersReq_Members_Pattern.MatchString(item) {
			return ReplacePolicyMembersReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "value does not match regex pattern \"^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$\"",
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ReplacePolicyMembersReqValidationError{}

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

var _ReplacePolicyMembersReq_Members_Pattern = regexp.MustCompile("^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$")

// Validate checks the field values on ReplacePolicyMembersResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *ReplacePolicyMembersResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ReplacePolicyMembersRespValidationError{}

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

// Validate checks the field values on AddPolicyMembersReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *AddPolicyMembersReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	if len(m.GetMembers()) < 1 {
		return AddPolicyMembersReqValidationError{
			field:  "Members",
			reason: "value must contain at least 1 item(s)",
		}
	}

	_AddPolicyMembersReq_Members_Unique := make(map[string]struct{}, len(m.GetMembers()))

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

		if _, exists := _AddPolicyMembersReq_Members_Unique[item]; exists {
			return AddPolicyMembersReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_AddPolicyMembersReq_Members_Unique[item] = struct{}{}
		}

		if !_AddPolicyMembersReq_Members_Pattern.MatchString(item) {
			return AddPolicyMembersReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "value does not match regex pattern \"^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$\"",
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = AddPolicyMembersReqValidationError{}

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

var _AddPolicyMembersReq_Members_Pattern = regexp.MustCompile("^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$")

// Validate checks the field values on AddPolicyMembersResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *AddPolicyMembersResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = AddPolicyMembersRespValidationError{}

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

// Validate checks the field values on Version with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *Version) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Major

	// no validation rules for Minor

	return nil
}

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

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

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

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

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

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

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

var _ error = VersionValidationError{}

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

// Validate checks the field values on GetPolicyVersionReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *GetPolicyVersionReq) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = GetPolicyVersionReqValidationError{}

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

// Validate checks the field values on GetPolicyVersionResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *GetPolicyVersionResp) Validate() error {
	if m == nil {
		return nil
	}

	if v, ok := interface{}(m.GetVersion()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetPolicyVersionRespValidationError{
				field:  "Version",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = GetPolicyVersionRespValidationError{}

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

// Validate checks the field values on ListRolesReq with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *ListRolesReq) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRolesReqValidationError{}

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

// Validate checks the field values on ListRolesResp with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *ListRolesResp) Validate() error {
	if m == nil {
		return nil
	}

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

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListRolesRespValidationError{
					field:  fmt.Sprintf("Roles[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRolesRespValidationError{}

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

// Validate checks the field values on DeleteRoleReq with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *DeleteRoleReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = DeleteRoleReqValidationError{}

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

// Validate checks the field values on DeleteRoleResp with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *DeleteRoleResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = DeleteRoleRespValidationError{}

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

// Validate checks the field values on UpdateRoleReq with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *UpdateRoleReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	// no validation rules for Name

	if len(m.GetActions()) < 1 {
		return UpdateRoleReqValidationError{
			field:  "Actions",
			reason: "value must contain at least 1 item(s)",
		}
	}

	_UpdateRoleReq_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _UpdateRoleReq_Actions_Unique[item]; exists {
			return UpdateRoleReqValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_UpdateRoleReq_Actions_Unique[item] = struct{}{}
		}

		if !_UpdateRoleReq_Actions_Pattern.MatchString(item) {
			return UpdateRoleReqValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value does not match regex pattern \"^[*]$|^[*]:[a-z][-a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[*]$|^[a-z][a-zA-Z]*:[*]:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[*]$\"",
			}
		}

	}

	_UpdateRoleReq_Projects_Unique := make(map[string]struct{}, len(m.GetProjects()))

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

		if _, exists := _UpdateRoleReq_Projects_Unique[item]; exists {
			return UpdateRoleReqValidationError{
				field:  fmt.Sprintf("Projects[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_UpdateRoleReq_Projects_Unique[item] = struct{}{}
		}

		// no validation rules for Projects[idx]
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = UpdateRoleReqValidationError{}

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

var _UpdateRoleReq_Actions_Pattern = regexp.MustCompile("^[*]$|^[*]:[a-z][-a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[*]$|^[a-z][a-zA-Z]*:[*]:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[*]$")

// Validate checks the field values on ListPolicyMembersReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *ListPolicyMembersReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = ListPolicyMembersReqValidationError{}

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

// Validate checks the field values on ListPolicyMembersResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *ListPolicyMembersResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListPolicyMembersRespValidationError{}

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

// Validate checks the field values on RemovePolicyMembersReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *RemovePolicyMembersReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	if len(m.GetMembers()) < 1 {
		return RemovePolicyMembersReqValidationError{
			field:  "Members",
			reason: "value must contain at least 1 item(s)",
		}
	}

	_RemovePolicyMembersReq_Members_Unique := make(map[string]struct{}, len(m.GetMembers()))

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

		if _, exists := _RemovePolicyMembersReq_Members_Unique[item]; exists {
			return RemovePolicyMembersReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_RemovePolicyMembersReq_Members_Unique[item] = struct{}{}
		}

		if !_RemovePolicyMembersReq_Members_Pattern.MatchString(item) {
			return RemovePolicyMembersReqValidationError{
				field:  fmt.Sprintf("Members[%v]", idx),
				reason: "value does not match regex pattern \"^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$\"",
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = RemovePolicyMembersReqValidationError{}

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

var _RemovePolicyMembersReq_Members_Pattern = regexp.MustCompile("^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|tls):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$")

// Validate checks the field values on RemovePolicyMembersResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *RemovePolicyMembersResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = RemovePolicyMembersRespValidationError{}

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

// Validate checks the field values on MigrateToV2Req with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *MigrateToV2Req) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Flag

	// no validation rules for SkipV1Policies

	return nil
}

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

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

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

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

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

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

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

var _ error = MigrateToV2ReqValidationError{}

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

// Validate checks the field values on MigrateToV2Resp with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *MigrateToV2Resp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = MigrateToV2RespValidationError{}

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

// Validate checks the field values on ResetToV1Req with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *ResetToV1Req) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ResetToV1ReqValidationError{}

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

// Validate checks the field values on ResetToV1Resp with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *ResetToV1Resp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ResetToV1RespValidationError{}

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

// Validate checks the field values on GetRoleReq with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *GetRoleReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = GetRoleReqValidationError{}

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

// Validate checks the field values on CreateRoleReq with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *CreateRoleReq) Validate() error {
	if m == nil {
		return nil
	}

	if !_CreateRoleReq_Id_Pattern.MatchString(m.GetId()) {
		return CreateRoleReqValidationError{
			field:  "Id",
			reason: "value does not match regex pattern \"^[a-z0-9-_]{1,64}$\"",
		}
	}

	// no validation rules for Name

	if len(m.GetActions()) < 1 {
		return CreateRoleReqValidationError{
			field:  "Actions",
			reason: "value must contain at least 1 item(s)",
		}
	}

	_CreateRoleReq_Actions_Unique := make(map[string]struct{}, len(m.GetActions()))

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

		if _, exists := _CreateRoleReq_Actions_Unique[item]; exists {
			return CreateRoleReqValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_CreateRoleReq_Actions_Unique[item] = struct{}{}
		}

		if !_CreateRoleReq_Actions_Pattern.MatchString(item) {
			return CreateRoleReqValidationError{
				field:  fmt.Sprintf("Actions[%v]", idx),
				reason: "value does not match regex pattern \"^[*]$|^[*]:[a-z][-a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[*]$|^[a-z][a-zA-Z]*:[*]:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[*]$\"",
			}
		}

	}

	_CreateRoleReq_Projects_Unique := make(map[string]struct{}, len(m.GetProjects()))

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

		if _, exists := _CreateRoleReq_Projects_Unique[item]; exists {
			return CreateRoleReqValidationError{
				field:  fmt.Sprintf("Projects[%v]", idx),
				reason: "repeated value must contain unique items",
			}
		} else {
			_CreateRoleReq_Projects_Unique[item] = struct{}{}
		}

		// no validation rules for Projects[idx]
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = CreateRoleReqValidationError{}

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

var _CreateRoleReq_Id_Pattern = regexp.MustCompile("^[a-z0-9-_]{1,64}$")

var _CreateRoleReq_Actions_Pattern = regexp.MustCompile("^[*]$|^[*]:[a-z][-a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[*]$|^[a-z][a-zA-Z]*:[*]:[a-z][a-zA-Z]*$|^[a-z][a-zA-Z]*:[a-z][a-zA-Z]*:[*]$")

// Validate checks the field values on PurgeSubjectFromPoliciesReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *PurgeSubjectFromPoliciesReq) Validate() error {
	if m == nil {
		return nil
	}

	if !_PurgeSubjectFromPoliciesReq_Subject_Pattern.MatchString(m.GetSubject()) {
		return PurgeSubjectFromPoliciesReqValidationError{
			field:  "Subject",
			reason: "value does not match regex pattern \"^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|service):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$\"",
		}
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = PurgeSubjectFromPoliciesReqValidationError{}

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

var _PurgeSubjectFromPoliciesReq_Subject_Pattern = regexp.MustCompile("^(?:team|user):(?:local|ldap|saml):(?:[^:*]+|[*])$|^(?:(?:team|user|token|service):)?[*]$|^token:[^:*]+$|^tls:service:(?:[^:*]+:)?(?:[^:*]+|[*])$")

// Validate checks the field values on PurgeSubjectFromPoliciesResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *PurgeSubjectFromPoliciesResp) Validate() error {
	if m == nil {
		return nil
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = PurgeSubjectFromPoliciesRespValidationError{}

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