project.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: interservice/authz/project.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 _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, an error is returned.
func (m *Project) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Name

	// no validation rules for Id

	// no validation rules for Type

	// no validation rules for Status

	return nil
}

// 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 CreateProjectReq with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *CreateProjectReq) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Name

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

	// no validation rules for SkipPolicies

	return nil
}

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

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

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

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

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

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

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

var _ error = CreateProjectReqValidationError{}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = CreateProjectRespValidationError{}

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

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

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = GetProjectReqValidationError{}

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = GetProjectRespValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ListProjectsReqValidationError{}

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

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

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListProjectsRespValidationError{}

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

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

	// no validation rules for Name

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = UpdateProjectReqValidationError{}

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = UpdateProjectRespValidationError{}

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

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

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = DeleteProjectReqValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = DeleteProjectRespValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ApplyRulesStartReqValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ApplyRulesStartRespValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ApplyRulesCancelReqValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ApplyRulesCancelRespValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ApplyRulesStatusReqValidationError{}

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

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

	// no validation rules for State

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

	// no validation rules for PercentageComplete

	// no validation rules for Failed

	// no validation rules for FailureMessage

	// no validation rules for Cancelled

	return nil
}

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

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

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

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

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

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

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

var _ error = ApplyRulesStatusRespValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRulesForAllProjectsReqValidationError{}

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

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

	for key, val := range m.GetProjectRules() {
		_ = val

		// no validation rules for ProjectRules[key]

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRulesForAllProjectsRespValidationError{}

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

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

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ProjectRulesValidationError{}

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

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

	// no validation rules for Id

	// no validation rules for ProjectId

	// no validation rules for Name

	// no validation rules for Type

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

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

	}

	// no validation rules for Deleted

	// no validation rules for Status

	return nil
}

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

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

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

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

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

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

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

var _ error = ProjectRuleValidationError{}

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

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

	// no validation rules for Attribute

	// no validation rules for Operator

	return nil
}

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

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

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

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

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

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

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

var _ error = ConditionValidationError{}

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

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

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

	// no validation rules for ProjectId

	// no validation rules for Name

	// no validation rules for Type

	if len(m.GetConditions()) < 1 {
		return CreateRuleReqValidationError{
			field:  "Conditions",
			reason: "value must contain at least 1 item(s)",
		}
	}

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = CreateRuleReqValidationError{}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = CreateRuleRespValidationError{}

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

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

	// no validation rules for Id

	// no validation rules for ProjectId

	// no validation rules for Name

	// no validation rules for Type

	if len(m.GetConditions()) < 1 {
		return UpdateRuleReqValidationError{
			field:  "Conditions",
			reason: "value must contain at least 1 item(s)",
		}
	}

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = UpdateRuleReqValidationError{}

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = UpdateRuleRespValidationError{}

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

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

	// no validation rules for Id

	// no validation rules for ProjectId

	return nil
}

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

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

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

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

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

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

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

var _ error = GetRuleReqValidationError{}

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = GetRuleRespValidationError{}

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

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

	// no validation rules for IncludeStaged

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRulesReqValidationError{}

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

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

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRulesRespValidationError{}

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

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

	// no validation rules for Id

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRulesForProjectReqValidationError{}

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

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

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

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

	}

	// no validation rules for Status

	return nil
}

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

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

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

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

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

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

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

var _ error = ListRulesForProjectRespValidationError{}

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

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

	// no validation rules for Id

	// no validation rules for ProjectId

	return nil
}

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

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

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

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

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

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

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

var _ error = DeleteRuleReqValidationError{}

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = DeleteRuleRespValidationError{}

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