base.pb.validate.go

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

package v1

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

	"google.golang.org/protobuf/types/known/anypb"
)

// ensure the imports are used
var (
	_ = bytes.MinRead
	_ = errors.New("")
	_ = fmt.Print
	_ = utf8.UTFMax
	_ = (*regexp.Regexp)(nil)
	_ = (*strings.Reader)(nil)
	_ = net.IPv4len
	_ = time.Duration(0)
	_ = (*url.URL)(nil)
	_ = (*mail.Address)(nil)
	_ = anypb.Any{}
)

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

	switch m.Type.(type) {

	case *Child_Leaf:

		if m.GetLeaf() == nil {
			return ChildValidationError{
				field:  "Leaf",
				reason: "value is required",
			}
		}

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

	case *Child_Rewrite:

		if m.GetRewrite() == nil {
			return ChildValidationError{
				field:  "Rewrite",
				reason: "value is required",
			}
		}

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

	default:
		return ChildValidationError{
			field:  "Type",
			reason: "value is required",
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ChildValidationError{}

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

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

	switch m.Type.(type) {

	case *Leaf_ComputedUserSet:

		if m.GetComputedUserSet() == nil {
			return LeafValidationError{
				field:  "ComputedUserSet",
				reason: "value is required",
			}
		}

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

	case *Leaf_TupleToUserSet:

		if m.GetTupleToUserSet() == nil {
			return LeafValidationError{
				field:  "TupleToUserSet",
				reason: "value is required",
			}
		}

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

	default:
		return LeafValidationError{
			field:  "Type",
			reason: "value is required",
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = LeafValidationError{}

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

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

	// no validation rules for RewriteOperation

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = RewriteValidationError{}

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

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

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

		// no validation rules for EntityDefinitions[key]

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = SchemaDefinitionValidationError{}

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

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

	if len(m.GetName()) > 64 {
		return EntityDefinitionValidationError{
			field:  "Name",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_EntityDefinition_Name_Pattern.MatchString(m.GetName()) {
		return EntityDefinitionValidationError{
			field:  "Name",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

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

		// no validation rules for Relations[key]

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

	}

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

		// no validation rules for Permissions[key]

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

	}

	// no validation rules for References

	return nil
}

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

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

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

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

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

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

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

var _ error = EntityDefinitionValidationError{}

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

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

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

	if len(m.GetName()) > 64 {
		return RelationDefinitionValidationError{
			field:  "Name",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_RelationDefinition_Name_Pattern.MatchString(m.GetName()) {
		return RelationDefinitionValidationError{
			field:  "Name",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = RelationDefinitionValidationError{}

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

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

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

	if len(m.GetName()) > 64 {
		return PermissionDefinitionValidationError{
			field:  "Name",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_PermissionDefinition_Name_Pattern.MatchString(m.GetName()) {
		return PermissionDefinitionValidationError{
			field:  "Name",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

var _ error = PermissionDefinitionValidationError{}

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

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

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

	if len(m.GetType()) > 64 {
		return RelationReferenceValidationError{
			field:  "Type",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_RelationReference_Type_Pattern.MatchString(m.GetType()) {
		return RelationReferenceValidationError{
			field:  "Type",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

	if m.GetRelation() != "" {

		if len(m.GetRelation()) > 64 {
			return RelationReferenceValidationError{
				field:  "Relation",
				reason: "value length must be at most 64 bytes",
			}
		}

		if !_RelationReference_Relation_Pattern.MatchString(m.GetRelation()) {
			return RelationReferenceValidationError{
				field:  "Relation",
				reason: "value does not match regex pattern \"^[a-z][a-z0-9_]{1,62}[a-z0-9]$\"",
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = RelationReferenceValidationError{}

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

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

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

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

	if len(m.GetRelation()) > 64 {
		return ComputedUserSetValidationError{
			field:  "Relation",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_ComputedUserSet_Relation_Pattern.MatchString(m.GetRelation()) {
		return ComputedUserSetValidationError{
			field:  "Relation",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9_]{1,62}[a-z0-9]$\"",
		}
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ComputedUserSetValidationError{}

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

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

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

	if len(m.GetRelation()) > 64 {
		return TupleSetValidationError{
			field:  "Relation",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_TupleSet_Relation_Pattern.MatchString(m.GetRelation()) {
		return TupleSetValidationError{
			field:  "Relation",
			reason: "value does not match regex pattern \"^[a-z][a-z0-9_]{1,62}[a-z0-9]$\"",
		}
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = TupleSetValidationError{}

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

var _ error = TupleToUserSetValidationError{}

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

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

	if m.GetEntity() == nil {
		return TupleValidationError{
			field:  "Entity",
			reason: "value is required",
		}
	}

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

	if len(m.GetRelation()) > 64 {
		return TupleValidationError{
			field:  "Relation",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_Tuple_Relation_Pattern.MatchString(m.GetRelation()) {
		return TupleValidationError{
			field:  "Relation",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

	if m.GetSubject() == nil {
		return TupleValidationError{
			field:  "Subject",
			reason: "value is required",
		}
	}

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

	return nil
}

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

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

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

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

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

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

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

var _ error = TupleValidationError{}

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

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

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

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = TuplesValidationError{}

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

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

	if len(m.GetType()) > 64 {
		return EntityValidationError{
			field:  "Type",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_Entity_Type_Pattern.MatchString(m.GetType()) {
		return EntityValidationError{
			field:  "Type",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

	if len(m.GetId()) > 128 {
		return EntityValidationError{
			field:  "Id",
			reason: "value length must be at most 128 bytes",
		}
	}

	if !_Entity_Id_Pattern.MatchString(m.GetId()) {
		return EntityValidationError{
			field:  "Id",
			reason: "value does not match regex pattern \"^(([a-zA-Z0-9_][a-zA-Z0-9_|-]{0,127})|\\\\*)$\"",
		}
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = EntityValidationError{}

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

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

var _Entity_Id_Pattern = regexp.MustCompile("^(([a-zA-Z0-9_][a-zA-Z0-9_|-]{0,127})|\\*)$")

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

	if m.GetEntity() == nil {
		return EntityAndRelationValidationError{
			field:  "Entity",
			reason: "value is required",
		}
	}

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

	if len(m.GetRelation()) > 64 {
		return EntityAndRelationValidationError{
			field:  "Relation",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_EntityAndRelation_Relation_Pattern.MatchString(m.GetRelation()) {
		return EntityAndRelationValidationError{
			field:  "Relation",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,64}[a-z0-9])$\"",
		}
	}

	return nil
}

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

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

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

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

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

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

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

var _ error = EntityAndRelationValidationError{}

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

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

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

	if len(m.GetType()) > 64 {
		return SubjectValidationError{
			field:  "Type",
			reason: "value length must be at most 64 bytes",
		}
	}

	if !_Subject_Type_Pattern.MatchString(m.GetType()) {
		return SubjectValidationError{
			field:  "Type",
			reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
		}
	}

	if len(m.GetId()) > 128 {
		return SubjectValidationError{
			field:  "Id",
			reason: "value length must be at most 128 bytes",
		}
	}

	if !_Subject_Id_Pattern.MatchString(m.GetId()) {
		return SubjectValidationError{
			field:  "Id",
			reason: "value does not match regex pattern \"^(([a-zA-Z0-9_][a-zA-Z0-9_|-]{0,127})|\\\\*)$\"",
		}
	}

	if m.GetRelation() != "" {

		if len(m.GetRelation()) > 64 {
			return SubjectValidationError{
				field:  "Relation",
				reason: "value length must be at most 64 bytes",
			}
		}

		if !_Subject_Relation_Pattern.MatchString(m.GetRelation()) {
			return SubjectValidationError{
				field:  "Relation",
				reason: "value does not match regex pattern \"^([.&a-z][.&a-z0-9_]{1,62}[.&a-z0-9])$\"",
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = SubjectValidationError{}

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

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

var _Subject_Id_Pattern = regexp.MustCompile("^(([a-zA-Z0-9_][a-zA-Z0-9_|-]{0,127})|\\*)$")

var _Subject_Relation_Pattern = regexp.MustCompile("^([.&a-z][.&a-z0-9_]{1,62}[.&a-z0-9])$")

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

	if m.GetEntity() == nil {
		return TupleFilterValidationError{
			field:  "Entity",
			reason: "value is required",
		}
	}

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

	if m.GetRelation() != "" {

		if len(m.GetRelation()) > 64 {
			return TupleFilterValidationError{
				field:  "Relation",
				reason: "value length must be at most 64 bytes",
			}
		}

		if !_TupleFilter_Relation_Pattern.MatchString(m.GetRelation()) {
			return TupleFilterValidationError{
				field:  "Relation",
				reason: "value does not match regex pattern \"^([a-z][a-z0-9_]{1,62}[a-z0-9])$\"",
			}
		}

	}

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

	return nil
}

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

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

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

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

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

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

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

var _ error = TupleFilterValidationError{}

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

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

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

	// no validation rules for Type

	return nil
}

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

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

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

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

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

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

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

var _ error = EntityFilterValidationError{}

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

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

	// no validation rules for Type

	if m.GetRelation() != "" {

		if len(m.GetRelation()) > 64 {
			return SubjectFilterValidationError{
				field:  "Relation",
				reason: "value length must be at most 64 bytes",
			}
		}

		if !_SubjectFilter_Relation_Pattern.MatchString(m.GetRelation()) {
			return SubjectFilterValidationError{
				field:  "Relation",
				reason: "value does not match regex pattern \"^([.&a-z][.&a-z0-9_]{1,62}[.&a-z0-9])$\"",
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = SubjectFilterValidationError{}

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

var _SubjectFilter_Relation_Pattern = regexp.MustCompile("^([.&a-z][.&a-z0-9_]{1,62}[.&a-z0-9])$")

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

	// no validation rules for Operation

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ExpandTreeNodeValidationError{}

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

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

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

	switch m.Node.(type) {

	case *Expand_Expand:

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

	case *Expand_Leaf:

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = ExpandValidationError{}

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

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

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = SubjectsValidationError{}

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

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

	// no validation rules for Id

	// no validation rules for Name

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

	return nil
}

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

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

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

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

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

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

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

var _ error = TenantValidationError{}

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

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

	// no validation rules for SnapToken

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

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

	}

	return nil
}

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

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

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

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

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

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

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

var _ error = TupleChangesValidationError{}

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

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

	// no validation rules for Operation

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

	return nil
}

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

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

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

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

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

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

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

var _ error = TupleChangeValidationError{}

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