// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        (unknown)
// source: base/v1/base.proto

package basev1

import (
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	v1alpha1 "google.golang.org/genproto/googleapis/api/expr/v1alpha1"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Enumerates results of a check operation.
type CheckResult int32

const (
	// Not specified check result. This is the default value.
	CheckResult_CHECK_RESULT_UNSPECIFIED CheckResult = 0
	// Represents a successful check (the check allowed the operation).
	CheckResult_CHECK_RESULT_ALLOWED CheckResult = 1
	// Represents a failed check (the check denied the operation).
	CheckResult_CHECK_RESULT_DENIED CheckResult = 2
)

// Enum value maps for CheckResult.
var (
	CheckResult_name = map[int32]string{
		0: "CHECK_RESULT_UNSPECIFIED",
		1: "CHECK_RESULT_ALLOWED",
		2: "CHECK_RESULT_DENIED",
	}
	CheckResult_value = map[string]int32{
		"CHECK_RESULT_UNSPECIFIED": 0,
		"CHECK_RESULT_ALLOWED":     1,
		"CHECK_RESULT_DENIED":      2,
	}
)

func (x CheckResult) Enum() *CheckResult {
	p := new(CheckResult)
	*p = x
	return p
}

func (x CheckResult) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CheckResult) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[0].Descriptor()
}

func (CheckResult) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[0]
}

func (x CheckResult) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use CheckResult.Descriptor instead.
func (CheckResult) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{0}
}

// Enumerates the types of attribute.
type AttributeType int32

const (
	// Not specified attribute type. This is the default value.
	AttributeType_ATTRIBUTE_TYPE_UNSPECIFIED AttributeType = 0
	// A boolean attribute type.
	AttributeType_ATTRIBUTE_TYPE_BOOLEAN AttributeType = 1
	// A boolean array attribute type.
	AttributeType_ATTRIBUTE_TYPE_BOOLEAN_ARRAY AttributeType = 2
	// A string attribute type.
	AttributeType_ATTRIBUTE_TYPE_STRING AttributeType = 3
	// A string array attribute type.
	AttributeType_ATTRIBUTE_TYPE_STRING_ARRAY AttributeType = 4
	// An integer attribute type.
	AttributeType_ATTRIBUTE_TYPE_INTEGER AttributeType = 5
	// An integer array attribute type.
	AttributeType_ATTRIBUTE_TYPE_INTEGER_ARRAY AttributeType = 6
	// A double attribute type.
	AttributeType_ATTRIBUTE_TYPE_DOUBLE AttributeType = 7
	// A double array attribute type.
	AttributeType_ATTRIBUTE_TYPE_DOUBLE_ARRAY AttributeType = 8
)

// Enum value maps for AttributeType.
var (
	AttributeType_name = map[int32]string{
		0: "ATTRIBUTE_TYPE_UNSPECIFIED",
		1: "ATTRIBUTE_TYPE_BOOLEAN",
		2: "ATTRIBUTE_TYPE_BOOLEAN_ARRAY",
		3: "ATTRIBUTE_TYPE_STRING",
		4: "ATTRIBUTE_TYPE_STRING_ARRAY",
		5: "ATTRIBUTE_TYPE_INTEGER",
		6: "ATTRIBUTE_TYPE_INTEGER_ARRAY",
		7: "ATTRIBUTE_TYPE_DOUBLE",
		8: "ATTRIBUTE_TYPE_DOUBLE_ARRAY",
	}
	AttributeType_value = map[string]int32{
		"ATTRIBUTE_TYPE_UNSPECIFIED":   0,
		"ATTRIBUTE_TYPE_BOOLEAN":       1,
		"ATTRIBUTE_TYPE_BOOLEAN_ARRAY": 2,
		"ATTRIBUTE_TYPE_STRING":        3,
		"ATTRIBUTE_TYPE_STRING_ARRAY":  4,
		"ATTRIBUTE_TYPE_INTEGER":       5,
		"ATTRIBUTE_TYPE_INTEGER_ARRAY": 6,
		"ATTRIBUTE_TYPE_DOUBLE":        7,
		"ATTRIBUTE_TYPE_DOUBLE_ARRAY":  8,
	}
)

func (x AttributeType) Enum() *AttributeType {
	p := new(AttributeType)
	*p = x
	return p
}

func (x AttributeType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AttributeType) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[1].Descriptor()
}

func (AttributeType) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[1]
}

func (x AttributeType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AttributeType.Descriptor instead.
func (AttributeType) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{1}
}

// Operation enum includes potential rewrite operations.
// OPERATION_UNION: Represents a union operation.
// OPERATION_INTERSECTION: Represents an intersection operation.
// OPERATION_EXCLUSION: Represents an exclusion operation.
type Rewrite_Operation int32

const (
	Rewrite_OPERATION_UNSPECIFIED  Rewrite_Operation = 0 // Default, unspecified operation.
	Rewrite_OPERATION_UNION        Rewrite_Operation = 1 // Represents a union operation.
	Rewrite_OPERATION_INTERSECTION Rewrite_Operation = 2 // Represents an intersection operation.
	Rewrite_OPERATION_EXCLUSION    Rewrite_Operation = 3 // Represents an exclusion operation.
)

// Enum value maps for Rewrite_Operation.
var (
	Rewrite_Operation_name = map[int32]string{
		0: "OPERATION_UNSPECIFIED",
		1: "OPERATION_UNION",
		2: "OPERATION_INTERSECTION",
		3: "OPERATION_EXCLUSION",
	}
	Rewrite_Operation_value = map[string]int32{
		"OPERATION_UNSPECIFIED":  0,
		"OPERATION_UNION":        1,
		"OPERATION_INTERSECTION": 2,
		"OPERATION_EXCLUSION":    3,
	}
)

func (x Rewrite_Operation) Enum() *Rewrite_Operation {
	p := new(Rewrite_Operation)
	*p = x
	return p
}

func (x Rewrite_Operation) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Rewrite_Operation) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[2].Descriptor()
}

func (Rewrite_Operation) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[2]
}

func (x Rewrite_Operation) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Rewrite_Operation.Descriptor instead.
func (Rewrite_Operation) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{3, 0}
}

// The Reference enum helps distinguish whether a name corresponds to an entity or a rule.
type SchemaDefinition_Reference int32

const (
	SchemaDefinition_REFERENCE_UNSPECIFIED SchemaDefinition_Reference = 0 // Default, unspecified reference.
	SchemaDefinition_REFERENCE_ENTITY      SchemaDefinition_Reference = 1 // Indicates that the name refers to an entity.
	SchemaDefinition_REFERENCE_RULE        SchemaDefinition_Reference = 2 // Indicates that the name refers to a rule.
)

// Enum value maps for SchemaDefinition_Reference.
var (
	SchemaDefinition_Reference_name = map[int32]string{
		0: "REFERENCE_UNSPECIFIED",
		1: "REFERENCE_ENTITY",
		2: "REFERENCE_RULE",
	}
	SchemaDefinition_Reference_value = map[string]int32{
		"REFERENCE_UNSPECIFIED": 0,
		"REFERENCE_ENTITY":      1,
		"REFERENCE_RULE":        2,
	}
)

func (x SchemaDefinition_Reference) Enum() *SchemaDefinition_Reference {
	p := new(SchemaDefinition_Reference)
	*p = x
	return p
}

func (x SchemaDefinition_Reference) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (SchemaDefinition_Reference) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[3].Descriptor()
}

func (SchemaDefinition_Reference) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[3]
}

func (x SchemaDefinition_Reference) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use SchemaDefinition_Reference.Descriptor instead.
func (SchemaDefinition_Reference) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{4, 0}
}

// The Reference enum specifies whether a name pertains to a relation, permission, or attribute.
type EntityDefinition_Reference int32

const (
	EntityDefinition_REFERENCE_UNSPECIFIED EntityDefinition_Reference = 0 // Default, unspecified reference.
	EntityDefinition_REFERENCE_RELATION    EntityDefinition_Reference = 1 // Indicates that the name refers to a relation.
	EntityDefinition_REFERENCE_PERMISSION  EntityDefinition_Reference = 2 // Indicates that the name refers to a permission.
	EntityDefinition_REFERENCE_ATTRIBUTE   EntityDefinition_Reference = 3 // Indicates that the name refers to an attribute.
)

// Enum value maps for EntityDefinition_Reference.
var (
	EntityDefinition_Reference_name = map[int32]string{
		0: "REFERENCE_UNSPECIFIED",
		1: "REFERENCE_RELATION",
		2: "REFERENCE_PERMISSION",
		3: "REFERENCE_ATTRIBUTE",
	}
	EntityDefinition_Reference_value = map[string]int32{
		"REFERENCE_UNSPECIFIED": 0,
		"REFERENCE_RELATION":    1,
		"REFERENCE_PERMISSION":  2,
		"REFERENCE_ATTRIBUTE":   3,
	}
)

func (x EntityDefinition_Reference) Enum() *EntityDefinition_Reference {
	p := new(EntityDefinition_Reference)
	*p = x
	return p
}

func (x EntityDefinition_Reference) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (EntityDefinition_Reference) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[4].Descriptor()
}

func (EntityDefinition_Reference) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[4]
}

func (x EntityDefinition_Reference) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use EntityDefinition_Reference.Descriptor instead.
func (EntityDefinition_Reference) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{5, 0}
}

// Operation is an enum representing the type of operation to be applied on the tree node.
type ExpandTreeNode_Operation int32

const (
	ExpandTreeNode_OPERATION_UNSPECIFIED  ExpandTreeNode_Operation = 0
	ExpandTreeNode_OPERATION_UNION        ExpandTreeNode_Operation = 1
	ExpandTreeNode_OPERATION_INTERSECTION ExpandTreeNode_Operation = 2
	ExpandTreeNode_OPERATION_EXCLUSION    ExpandTreeNode_Operation = 3
)

// Enum value maps for ExpandTreeNode_Operation.
var (
	ExpandTreeNode_Operation_name = map[int32]string{
		0: "OPERATION_UNSPECIFIED",
		1: "OPERATION_UNION",
		2: "OPERATION_INTERSECTION",
		3: "OPERATION_EXCLUSION",
	}
	ExpandTreeNode_Operation_value = map[string]int32{
		"OPERATION_UNSPECIFIED":  0,
		"OPERATION_UNION":        1,
		"OPERATION_INTERSECTION": 2,
		"OPERATION_EXCLUSION":    3,
	}
)

func (x ExpandTreeNode_Operation) Enum() *ExpandTreeNode_Operation {
	p := new(ExpandTreeNode_Operation)
	*p = x
	return p
}

func (x ExpandTreeNode_Operation) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ExpandTreeNode_Operation) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[5].Descriptor()
}

func (ExpandTreeNode_Operation) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[5]
}

func (x ExpandTreeNode_Operation) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ExpandTreeNode_Operation.Descriptor instead.
func (ExpandTreeNode_Operation) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{29, 0}
}

type DataChange_Operation int32

const (
	DataChange_OPERATION_UNSPECIFIED DataChange_Operation = 0 // Default operation, not specified.
	DataChange_OPERATION_CREATE      DataChange_Operation = 1 // Creation operation.
	DataChange_OPERATION_DELETE      DataChange_Operation = 2 // Deletion operation.
)

// Enum value maps for DataChange_Operation.
var (
	DataChange_Operation_name = map[int32]string{
		0: "OPERATION_UNSPECIFIED",
		1: "OPERATION_CREATE",
		2: "OPERATION_DELETE",
	}
	DataChange_Operation_value = map[string]int32{
		"OPERATION_UNSPECIFIED": 0,
		"OPERATION_CREATE":      1,
		"OPERATION_DELETE":      2,
	}
)

func (x DataChange_Operation) Enum() *DataChange_Operation {
	p := new(DataChange_Operation)
	*p = x
	return p
}

func (x DataChange_Operation) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (DataChange_Operation) Descriptor() protoreflect.EnumDescriptor {
	return file_base_v1_base_proto_enumTypes[6].Descriptor()
}

func (DataChange_Operation) Type() protoreflect.EnumType {
	return &file_base_v1_base_proto_enumTypes[6]
}

func (x DataChange_Operation) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use DataChange_Operation.Descriptor instead.
func (DataChange_Operation) EnumDescriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{36, 0}
}

// Context encapsulates the information related to a single operation,
// including the tuples involved and the associated attributes.
type Context struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A repeated field of tuples involved in the operation.
	Tuples []*Tuple `protobuf:"bytes,1,rep,name=tuples,proto3" json:"tuples,omitempty"`
	// A repeated field of attributes associated with the operation.
	Attributes []*Attribute `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"`
	// Additional data associated with the context.
	Data          *structpb.Struct `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Context) Reset() {
	*x = Context{}
	mi := &file_base_v1_base_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Context) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Context) ProtoMessage() {}

func (x *Context) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Context.ProtoReflect.Descriptor instead.
func (*Context) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{0}
}

func (x *Context) GetTuples() []*Tuple {
	if x != nil {
		return x.Tuples
	}
	return nil
}

func (x *Context) GetAttributes() []*Attribute {
	if x != nil {
		return x.Attributes
	}
	return nil
}

func (x *Context) GetData() *structpb.Struct {
	if x != nil {
		return x.Data
	}
	return nil
}

// Child represents a node in the permission tree.
type Child struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Child node can be either a leaf or a rewrite operation.
	//
	// Types that are valid to be assigned to Type:
	//
	//	*Child_Leaf
	//	*Child_Rewrite
	Type          isChild_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Child) Reset() {
	*x = Child{}
	mi := &file_base_v1_base_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Child) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Child) ProtoMessage() {}

func (x *Child) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Child.ProtoReflect.Descriptor instead.
func (*Child) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{1}
}

func (x *Child) GetType() isChild_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *Child) GetLeaf() *Leaf {
	if x != nil {
		if x, ok := x.Type.(*Child_Leaf); ok {
			return x.Leaf
		}
	}
	return nil
}

func (x *Child) GetRewrite() *Rewrite {
	if x != nil {
		if x, ok := x.Type.(*Child_Rewrite); ok {
			return x.Rewrite
		}
	}
	return nil
}

type isChild_Type interface {
	isChild_Type()
}

type Child_Leaf struct {
	// Leaf node in the permission tree.
	Leaf *Leaf `protobuf:"bytes,1,opt,name=leaf,proto3,oneof"`
}

type Child_Rewrite struct {
	// Rewrite operation in the permission tree.
	Rewrite *Rewrite `protobuf:"bytes,2,opt,name=rewrite,proto3,oneof"`
}

func (*Child_Leaf) isChild_Type() {}

func (*Child_Rewrite) isChild_Type() {}

// Leaf represents a leaf node in the permission tree.
type Leaf struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Leaf node can be one of several types.
	//
	// Types that are valid to be assigned to Type:
	//
	//	*Leaf_ComputedUserSet
	//	*Leaf_TupleToUserSet
	//	*Leaf_ComputedAttribute
	//	*Leaf_Call
	Type          isLeaf_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Leaf) Reset() {
	*x = Leaf{}
	mi := &file_base_v1_base_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Leaf) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Leaf) ProtoMessage() {}

func (x *Leaf) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Leaf.ProtoReflect.Descriptor instead.
func (*Leaf) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{2}
}

func (x *Leaf) GetType() isLeaf_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *Leaf) GetComputedUserSet() *ComputedUserSet {
	if x != nil {
		if x, ok := x.Type.(*Leaf_ComputedUserSet); ok {
			return x.ComputedUserSet
		}
	}
	return nil
}

func (x *Leaf) GetTupleToUserSet() *TupleToUserSet {
	if x != nil {
		if x, ok := x.Type.(*Leaf_TupleToUserSet); ok {
			return x.TupleToUserSet
		}
	}
	return nil
}

func (x *Leaf) GetComputedAttribute() *ComputedAttribute {
	if x != nil {
		if x, ok := x.Type.(*Leaf_ComputedAttribute); ok {
			return x.ComputedAttribute
		}
	}
	return nil
}

func (x *Leaf) GetCall() *Call {
	if x != nil {
		if x, ok := x.Type.(*Leaf_Call); ok {
			return x.Call
		}
	}
	return nil
}

type isLeaf_Type interface {
	isLeaf_Type()
}

type Leaf_ComputedUserSet struct {
	// A computed set of users.
	ComputedUserSet *ComputedUserSet `protobuf:"bytes,1,opt,name=computed_user_set,json=computedUserSet,proto3,oneof"`
}

type Leaf_TupleToUserSet struct {
	// A tuple to user set conversion.
	TupleToUserSet *TupleToUserSet `protobuf:"bytes,2,opt,name=tuple_to_user_set,json=tupleToUserSet,proto3,oneof"`
}

type Leaf_ComputedAttribute struct {
	// A computed attribute.
	ComputedAttribute *ComputedAttribute `protobuf:"bytes,3,opt,name=computed_attribute,json=computedAttribute,proto3,oneof"`
}

type Leaf_Call struct {
	// A call to a function or method.
	Call *Call `protobuf:"bytes,4,opt,name=call,proto3,oneof"`
}

func (*Leaf_ComputedUserSet) isLeaf_Type() {}

func (*Leaf_TupleToUserSet) isLeaf_Type() {}

func (*Leaf_ComputedAttribute) isLeaf_Type() {}

func (*Leaf_Call) isLeaf_Type() {}

// The Rewrite message represents a specific rewrite operation.
// This operation could be one of the following: union, intersection, or exclusion.
type Rewrite struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of rewrite operation to be performed.
	RewriteOperation Rewrite_Operation `protobuf:"varint,1,opt,name=rewrite_operation,json=rewriteOperation,proto3,enum=base.v1.Rewrite_Operation" json:"rewrite_operation,omitempty"`
	// A list of children that are operated upon by the rewrite operation.
	Children      []*Child `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Rewrite) Reset() {
	*x = Rewrite{}
	mi := &file_base_v1_base_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Rewrite) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Rewrite) ProtoMessage() {}

func (x *Rewrite) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Rewrite.ProtoReflect.Descriptor instead.
func (*Rewrite) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{3}
}

func (x *Rewrite) GetRewriteOperation() Rewrite_Operation {
	if x != nil {
		return x.RewriteOperation
	}
	return Rewrite_OPERATION_UNSPECIFIED
}

func (x *Rewrite) GetChildren() []*Child {
	if x != nil {
		return x.Children
	}
	return nil
}

// The SchemaDefinition message provides definitions for entities and rules,
// and includes references to clarify whether a name refers to an entity or a rule.
type SchemaDefinition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Map of entity definitions. The key is the entity name, and the value is the corresponding EntityDefinition.
	EntityDefinitions map[string]*EntityDefinition `protobuf:"bytes,1,rep,name=entity_definitions,json=entityDefinitions,proto3" json:"entity_definitions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Map of rule definitions. The key is the rule name, and the value is the corresponding RuleDefinition.
	RuleDefinitions map[string]*RuleDefinition `protobuf:"bytes,2,rep,name=rule_definitions,json=ruleDefinitions,proto3" json:"rule_definitions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Map of references to signify whether a string refers to an entity or a rule.
	References    map[string]SchemaDefinition_Reference `protobuf:"bytes,3,rep,name=references,proto3" json:"references,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=base.v1.SchemaDefinition_Reference"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SchemaDefinition) Reset() {
	*x = SchemaDefinition{}
	mi := &file_base_v1_base_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SchemaDefinition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SchemaDefinition) ProtoMessage() {}

func (x *SchemaDefinition) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SchemaDefinition.ProtoReflect.Descriptor instead.
func (*SchemaDefinition) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{4}
}

func (x *SchemaDefinition) GetEntityDefinitions() map[string]*EntityDefinition {
	if x != nil {
		return x.EntityDefinitions
	}
	return nil
}

func (x *SchemaDefinition) GetRuleDefinitions() map[string]*RuleDefinition {
	if x != nil {
		return x.RuleDefinitions
	}
	return nil
}

func (x *SchemaDefinition) GetReferences() map[string]SchemaDefinition_Reference {
	if x != nil {
		return x.References
	}
	return nil
}

// The EntityDefinition message provides detailed information about a specific entity.
type EntityDefinition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the entity, which follows a specific string pattern and has a maximum byte size.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Map of relation definitions within this entity. The key is the relation name, and the value is the RelationDefinition.
	Relations map[string]*RelationDefinition `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Map of permission definitions within this entity. The key is the permission name, and the value is the PermissionDefinition.
	Permissions map[string]*PermissionDefinition `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Map of attribute definitions within this entity. The key is the attribute name, and the value is the AttributeDefinition.
	Attributes map[string]*AttributeDefinition `protobuf:"bytes,4,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Map of references indicating whether a string pertains to a relation, permission, or attribute.
	References    map[string]EntityDefinition_Reference `protobuf:"bytes,5,rep,name=references,proto3" json:"references,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=base.v1.EntityDefinition_Reference"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EntityDefinition) Reset() {
	*x = EntityDefinition{}
	mi := &file_base_v1_base_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EntityDefinition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EntityDefinition) ProtoMessage() {}

func (x *EntityDefinition) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EntityDefinition.ProtoReflect.Descriptor instead.
func (*EntityDefinition) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{5}
}

func (x *EntityDefinition) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *EntityDefinition) GetRelations() map[string]*RelationDefinition {
	if x != nil {
		return x.Relations
	}
	return nil
}

func (x *EntityDefinition) GetPermissions() map[string]*PermissionDefinition {
	if x != nil {
		return x.Permissions
	}
	return nil
}

func (x *EntityDefinition) GetAttributes() map[string]*AttributeDefinition {
	if x != nil {
		return x.Attributes
	}
	return nil
}

func (x *EntityDefinition) GetReferences() map[string]EntityDefinition_Reference {
	if x != nil {
		return x.References
	}
	return nil
}

// The RuleDefinition message provides detailed information about a specific rule.
type RuleDefinition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the rule, which follows a specific string pattern and has a maximum byte size.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Map of arguments for this rule. The key is the attribute name, and the value is the AttributeType.
	Arguments map[string]AttributeType `protobuf:"bytes,2,rep,name=arguments,proto3" json:"arguments,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=base.v1.AttributeType"`
	// The expression for this rule in the form of a google.api.expr.v1alpha1.CheckedExpr.
	Expression    *v1alpha1.CheckedExpr `protobuf:"bytes,3,opt,name=expression,proto3" json:"expression,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RuleDefinition) Reset() {
	*x = RuleDefinition{}
	mi := &file_base_v1_base_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RuleDefinition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RuleDefinition) ProtoMessage() {}

func (x *RuleDefinition) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RuleDefinition.ProtoReflect.Descriptor instead.
func (*RuleDefinition) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{6}
}

func (x *RuleDefinition) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RuleDefinition) GetArguments() map[string]AttributeType {
	if x != nil {
		return x.Arguments
	}
	return nil
}

func (x *RuleDefinition) GetExpression() *v1alpha1.CheckedExpr {
	if x != nil {
		return x.Expression
	}
	return nil
}

// The AttributeDefinition message provides detailed information about a specific attribute.
type AttributeDefinition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the attribute, which follows a specific string pattern and has a maximum byte size.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The type of the attribute.
	Type          AttributeType `protobuf:"varint,2,opt,name=type,proto3,enum=base.v1.AttributeType" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AttributeDefinition) Reset() {
	*x = AttributeDefinition{}
	mi := &file_base_v1_base_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AttributeDefinition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AttributeDefinition) ProtoMessage() {}

func (x *AttributeDefinition) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AttributeDefinition.ProtoReflect.Descriptor instead.
func (*AttributeDefinition) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{7}
}

func (x *AttributeDefinition) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *AttributeDefinition) GetType() AttributeType {
	if x != nil {
		return x.Type
	}
	return AttributeType_ATTRIBUTE_TYPE_UNSPECIFIED
}

// The RelationDefinition message provides detailed information about a specific relation.
type RelationDefinition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the relation, which follows a specific string pattern and has a maximum byte size.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A list of references to other relations.
	RelationReferences []*RelationReference `protobuf:"bytes,2,rep,name=relation_references,json=relationReferences,proto3" json:"relation_references,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *RelationDefinition) Reset() {
	*x = RelationDefinition{}
	mi := &file_base_v1_base_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RelationDefinition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RelationDefinition) ProtoMessage() {}

func (x *RelationDefinition) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RelationDefinition.ProtoReflect.Descriptor instead.
func (*RelationDefinition) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{8}
}

func (x *RelationDefinition) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RelationDefinition) GetRelationReferences() []*RelationReference {
	if x != nil {
		return x.RelationReferences
	}
	return nil
}

// The PermissionDefinition message provides detailed information about a specific permission.
type PermissionDefinition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the permission, which follows a specific string pattern and has a maximum byte size.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The child related to this permission.
	Child         *Child `protobuf:"bytes,2,opt,name=child,proto3" json:"child,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PermissionDefinition) Reset() {
	*x = PermissionDefinition{}
	mi := &file_base_v1_base_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PermissionDefinition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PermissionDefinition) ProtoMessage() {}

func (x *PermissionDefinition) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PermissionDefinition.ProtoReflect.Descriptor instead.
func (*PermissionDefinition) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{9}
}

func (x *PermissionDefinition) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *PermissionDefinition) GetChild() *Child {
	if x != nil {
		return x.Child
	}
	return nil
}

// The RelationReference message provides a reference to a specific relation.
type RelationReference struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of the referenced entity, which follows a specific string pattern and has a maximum byte size.
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// The name of the referenced relation, which follows a specific string pattern and has a maximum byte size.
	Relation      string `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RelationReference) Reset() {
	*x = RelationReference{}
	mi := &file_base_v1_base_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RelationReference) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RelationReference) ProtoMessage() {}

func (x *RelationReference) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RelationReference.ProtoReflect.Descriptor instead.
func (*RelationReference) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{10}
}

func (x *RelationReference) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *RelationReference) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

type Entrance struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of the entrance entity, which follows a specific string pattern and has a maximum byte size.
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// The value associated with the entrance, which follows a specific string pattern and has a maximum byte size.
	Value         string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Entrance) Reset() {
	*x = Entrance{}
	mi := &file_base_v1_base_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Entrance) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Entrance) ProtoMessage() {}

func (x *Entrance) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Entrance.ProtoReflect.Descriptor instead.
func (*Entrance) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{11}
}

func (x *Entrance) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *Entrance) GetValue() string {
	if x != nil {
		return x.Value
	}
	return ""
}

// Argument defines the type of argument in a Call. It can be either a ComputedAttribute or a ContextAttribute.
type Argument struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Type:
	//
	//	*Argument_ComputedAttribute
	Type          isArgument_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Argument) Reset() {
	*x = Argument{}
	mi := &file_base_v1_base_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Argument) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Argument) ProtoMessage() {}

func (x *Argument) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Argument.ProtoReflect.Descriptor instead.
func (*Argument) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{12}
}

func (x *Argument) GetType() isArgument_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *Argument) GetComputedAttribute() *ComputedAttribute {
	if x != nil {
		if x, ok := x.Type.(*Argument_ComputedAttribute); ok {
			return x.ComputedAttribute
		}
	}
	return nil
}

type isArgument_Type interface {
	isArgument_Type()
}

type Argument_ComputedAttribute struct {
	ComputedAttribute *ComputedAttribute `protobuf:"bytes,1,opt,name=computed_attribute,json=computedAttribute,proto3,oneof"`
}

func (*Argument_ComputedAttribute) isArgument_Type() {}

// Call represents a call to a rule. It includes the name of the rule and the arguments passed to it.
type Call struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RuleName      string                 `protobuf:"bytes,1,opt,name=rule_name,json=ruleName,proto3" json:"rule_name,omitempty"` // Name of the rule
	Arguments     []*Argument            `protobuf:"bytes,2,rep,name=arguments,proto3" json:"arguments,omitempty"`               // Arguments passed to the rule
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Call) Reset() {
	*x = Call{}
	mi := &file_base_v1_base_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Call) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Call) ProtoMessage() {}

func (x *Call) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Call.ProtoReflect.Descriptor instead.
func (*Call) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{13}
}

func (x *Call) GetRuleName() string {
	if x != nil {
		return x.RuleName
	}
	return ""
}

func (x *Call) GetArguments() []*Argument {
	if x != nil {
		return x.Arguments
	}
	return nil
}

// ComputedAttribute defines a computed attribute which includes its name.
type ComputedAttribute struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Name of the computed attribute
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ComputedAttribute) Reset() {
	*x = ComputedAttribute{}
	mi := &file_base_v1_base_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ComputedAttribute) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ComputedAttribute) ProtoMessage() {}

func (x *ComputedAttribute) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ComputedAttribute.ProtoReflect.Descriptor instead.
func (*ComputedAttribute) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{14}
}

func (x *ComputedAttribute) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

// ComputedUserSet defines a set of computed users which includes the relation name.
type ComputedUserSet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Relation      string                 `protobuf:"bytes,1,opt,name=relation,proto3" json:"relation,omitempty"` // Relation name
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ComputedUserSet) Reset() {
	*x = ComputedUserSet{}
	mi := &file_base_v1_base_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ComputedUserSet) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ComputedUserSet) ProtoMessage() {}

func (x *ComputedUserSet) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ComputedUserSet.ProtoReflect.Descriptor instead.
func (*ComputedUserSet) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{15}
}

func (x *ComputedUserSet) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

// TupleToUserSet defines a mapping from tuple sets to computed user sets.
type TupleToUserSet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TupleSet      *TupleSet              `protobuf:"bytes,1,opt,name=tupleSet,proto3" json:"tupleSet,omitempty"` // The tuple set
	Computed      *ComputedUserSet       `protobuf:"bytes,2,opt,name=computed,proto3" json:"computed,omitempty"` // The computed user set
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TupleToUserSet) Reset() {
	*x = TupleToUserSet{}
	mi := &file_base_v1_base_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TupleToUserSet) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TupleToUserSet) ProtoMessage() {}

func (x *TupleToUserSet) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TupleToUserSet.ProtoReflect.Descriptor instead.
func (*TupleToUserSet) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{16}
}

func (x *TupleToUserSet) GetTupleSet() *TupleSet {
	if x != nil {
		return x.TupleSet
	}
	return nil
}

func (x *TupleToUserSet) GetComputed() *ComputedUserSet {
	if x != nil {
		return x.Computed
	}
	return nil
}

// TupleSet represents a set of tuples associated with a specific relation.
type TupleSet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Relation      string                 `protobuf:"bytes,1,opt,name=relation,proto3" json:"relation,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TupleSet) Reset() {
	*x = TupleSet{}
	mi := &file_base_v1_base_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TupleSet) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TupleSet) ProtoMessage() {}

func (x *TupleSet) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TupleSet.ProtoReflect.Descriptor instead.
func (*TupleSet) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{17}
}

func (x *TupleSet) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

// Tuple is a structure that includes an entity, a relation, and a subject.
type Tuple struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entity        *Entity                `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
	Relation      string                 `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
	Subject       *Subject               `protobuf:"bytes,3,opt,name=subject,proto3" json:"subject,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Tuple) Reset() {
	*x = Tuple{}
	mi := &file_base_v1_base_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Tuple) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Tuple) ProtoMessage() {}

func (x *Tuple) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Tuple.ProtoReflect.Descriptor instead.
func (*Tuple) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{18}
}

func (x *Tuple) GetEntity() *Entity {
	if x != nil {
		return x.Entity
	}
	return nil
}

func (x *Tuple) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

func (x *Tuple) GetSubject() *Subject {
	if x != nil {
		return x.Subject
	}
	return nil
}

// Attribute represents an attribute of an entity with a specific type and value.
type Attribute struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entity        *Entity                `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
	Attribute     string                 `protobuf:"bytes,2,opt,name=attribute,proto3" json:"attribute,omitempty"` // Name of the attribute
	Value         *anypb.Any             `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Attribute) Reset() {
	*x = Attribute{}
	mi := &file_base_v1_base_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Attribute) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Attribute) ProtoMessage() {}

func (x *Attribute) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Attribute.ProtoReflect.Descriptor instead.
func (*Attribute) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{19}
}

func (x *Attribute) GetEntity() *Entity {
	if x != nil {
		return x.Entity
	}
	return nil
}

func (x *Attribute) GetAttribute() string {
	if x != nil {
		return x.Attribute
	}
	return ""
}

func (x *Attribute) GetValue() *anypb.Any {
	if x != nil {
		return x.Value
	}
	return nil
}

// Tuples is a collection of tuples.
type Tuples struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Tuples        []*Tuple               `protobuf:"bytes,1,rep,name=tuples,proto3" json:"tuples,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Tuples) Reset() {
	*x = Tuples{}
	mi := &file_base_v1_base_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Tuples) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Tuples) ProtoMessage() {}

func (x *Tuples) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Tuples.ProtoReflect.Descriptor instead.
func (*Tuples) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{20}
}

func (x *Tuples) GetTuples() []*Tuple {
	if x != nil {
		return x.Tuples
	}
	return nil
}

// Attributes is a collection of attributes.
type Attributes struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Attributes    []*Attribute           `protobuf:"bytes,1,rep,name=attributes,proto3" json:"attributes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Attributes) Reset() {
	*x = Attributes{}
	mi := &file_base_v1_base_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Attributes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Attributes) ProtoMessage() {}

func (x *Attributes) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Attributes.ProtoReflect.Descriptor instead.
func (*Attributes) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{21}
}

func (x *Attributes) GetAttributes() []*Attribute {
	if x != nil {
		return x.Attributes
	}
	return nil
}

// Entity represents an entity with a type and an identifier.
type Entity struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Entity) Reset() {
	*x = Entity{}
	mi := &file_base_v1_base_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Entity) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Entity) ProtoMessage() {}

func (x *Entity) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Entity.ProtoReflect.Descriptor instead.
func (*Entity) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{22}
}

func (x *Entity) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *Entity) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// EntityAndRelation represents an entity along with a relation.
type EntityAndRelation struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entity        *Entity                `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
	Relation      string                 `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EntityAndRelation) Reset() {
	*x = EntityAndRelation{}
	mi := &file_base_v1_base_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EntityAndRelation) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EntityAndRelation) ProtoMessage() {}

func (x *EntityAndRelation) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EntityAndRelation.ProtoReflect.Descriptor instead.
func (*EntityAndRelation) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{23}
}

func (x *EntityAndRelation) GetEntity() *Entity {
	if x != nil {
		return x.Entity
	}
	return nil
}

func (x *EntityAndRelation) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

// Subject represents an entity subject with a type, an identifier, and a relation.
type Subject struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Relation      string                 `protobuf:"bytes,3,opt,name=relation,proto3" json:"relation,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Subject) Reset() {
	*x = Subject{}
	mi := &file_base_v1_base_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Subject) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Subject) ProtoMessage() {}

func (x *Subject) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[24]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Subject.ProtoReflect.Descriptor instead.
func (*Subject) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{24}
}

func (x *Subject) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *Subject) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *Subject) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

// AttributeFilter is used to filter attributes based on the entity and attribute names.
type AttributeFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entity        *EntityFilter          `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
	Attributes    []string               `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"` // Names of the attributes to be filtered
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AttributeFilter) Reset() {
	*x = AttributeFilter{}
	mi := &file_base_v1_base_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AttributeFilter) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AttributeFilter) ProtoMessage() {}

func (x *AttributeFilter) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[25]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AttributeFilter.ProtoReflect.Descriptor instead.
func (*AttributeFilter) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{25}
}

func (x *AttributeFilter) GetEntity() *EntityFilter {
	if x != nil {
		return x.Entity
	}
	return nil
}

func (x *AttributeFilter) GetAttributes() []string {
	if x != nil {
		return x.Attributes
	}
	return nil
}

// TupleFilter is used to filter tuples based on the entity, relation and the subject.
type TupleFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entity        *EntityFilter          `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
	Relation      string                 `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
	Subject       *SubjectFilter         `protobuf:"bytes,3,opt,name=subject,proto3" json:"subject,omitempty"` // The subject filter
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TupleFilter) Reset() {
	*x = TupleFilter{}
	mi := &file_base_v1_base_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TupleFilter) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TupleFilter) ProtoMessage() {}

func (x *TupleFilter) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[26]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TupleFilter.ProtoReflect.Descriptor instead.
func (*TupleFilter) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{26}
}

func (x *TupleFilter) GetEntity() *EntityFilter {
	if x != nil {
		return x.Entity
	}
	return nil
}

func (x *TupleFilter) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

func (x *TupleFilter) GetSubject() *SubjectFilter {
	if x != nil {
		return x.Subject
	}
	return nil
}

// EntityFilter is used to filter entities based on the type and ids.
type EntityFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` // Type of the entity
	Ids           []string               `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`   // List of entity IDs
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EntityFilter) Reset() {
	*x = EntityFilter{}
	mi := &file_base_v1_base_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EntityFilter) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EntityFilter) ProtoMessage() {}

func (x *EntityFilter) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[27]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EntityFilter.ProtoReflect.Descriptor instead.
func (*EntityFilter) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{27}
}

func (x *EntityFilter) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *EntityFilter) GetIds() []string {
	if x != nil {
		return x.Ids
	}
	return nil
}

// SubjectFilter is used to filter subjects based on the type, ids and relation.
type SubjectFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` // Type of the subject
	Ids           []string               `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`   // List of subject IDs
	Relation      string                 `protobuf:"bytes,3,opt,name=relation,proto3" json:"relation,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubjectFilter) Reset() {
	*x = SubjectFilter{}
	mi := &file_base_v1_base_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SubjectFilter) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SubjectFilter) ProtoMessage() {}

func (x *SubjectFilter) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[28]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SubjectFilter.ProtoReflect.Descriptor instead.
func (*SubjectFilter) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{28}
}

func (x *SubjectFilter) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *SubjectFilter) GetIds() []string {
	if x != nil {
		return x.Ids
	}
	return nil
}

func (x *SubjectFilter) GetRelation() string {
	if x != nil {
		return x.Relation
	}
	return ""
}

// ExpandTreeNode represents a node in an expansion tree with a specific operation and its children.
type ExpandTreeNode struct {
	state         protoimpl.MessageState   `protogen:"open.v1"`
	Operation     ExpandTreeNode_Operation `protobuf:"varint,1,opt,name=operation,proto3,enum=base.v1.ExpandTreeNode_Operation" json:"operation,omitempty"` // Operation to be applied on this tree node
	Children      []*Expand                `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"`                                          // The children of this tree node
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExpandTreeNode) Reset() {
	*x = ExpandTreeNode{}
	mi := &file_base_v1_base_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ExpandTreeNode) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ExpandTreeNode) ProtoMessage() {}

func (x *ExpandTreeNode) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[29]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ExpandTreeNode.ProtoReflect.Descriptor instead.
func (*ExpandTreeNode) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{29}
}

func (x *ExpandTreeNode) GetOperation() ExpandTreeNode_Operation {
	if x != nil {
		return x.Operation
	}
	return ExpandTreeNode_OPERATION_UNSPECIFIED
}

func (x *ExpandTreeNode) GetChildren() []*Expand {
	if x != nil {
		return x.Children
	}
	return nil
}

// Expand is used to define a hierarchical structure for permissions.
// It has an entity, permission, and arguments. The node can be either another hierarchical structure or a set of subjects.
type Expand struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// entity is the entity for which the hierarchical structure is defined.
	Entity *Entity `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
	// permission is the permission applied to the entity.
	Permission string `protobuf:"bytes,2,opt,name=permission,proto3" json:"permission,omitempty"`
	// arguments are the additional information or context used to evaluate permissions.
	Arguments []*Argument `protobuf:"bytes,3,rep,name=arguments,proto3" json:"arguments,omitempty"`
	// The node can either be an ExpandTreeNode or a set of Subjects.
	//
	// Types that are valid to be assigned to Node:
	//
	//	*Expand_Expand
	//	*Expand_Leaf
	Node          isExpand_Node `protobuf_oneof:"node"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Expand) Reset() {
	*x = Expand{}
	mi := &file_base_v1_base_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Expand) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Expand) ProtoMessage() {}

func (x *Expand) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[30]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Expand.ProtoReflect.Descriptor instead.
func (*Expand) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{30}
}

func (x *Expand) GetEntity() *Entity {
	if x != nil {
		return x.Entity
	}
	return nil
}

func (x *Expand) GetPermission() string {
	if x != nil {
		return x.Permission
	}
	return ""
}

func (x *Expand) GetArguments() []*Argument {
	if x != nil {
		return x.Arguments
	}
	return nil
}

func (x *Expand) GetNode() isExpand_Node {
	if x != nil {
		return x.Node
	}
	return nil
}

func (x *Expand) GetExpand() *ExpandTreeNode {
	if x != nil {
		if x, ok := x.Node.(*Expand_Expand); ok {
			return x.Expand
		}
	}
	return nil
}

func (x *Expand) GetLeaf() *ExpandLeaf {
	if x != nil {
		if x, ok := x.Node.(*Expand_Leaf); ok {
			return x.Leaf
		}
	}
	return nil
}

type isExpand_Node interface {
	isExpand_Node()
}

type Expand_Expand struct {
	// expand contains another hierarchical structure.
	Expand *ExpandTreeNode `protobuf:"bytes,4,opt,name=expand,proto3,oneof"`
}

type Expand_Leaf struct {
	// leaf contains a set of subjects.
	Leaf *ExpandLeaf `protobuf:"bytes,5,opt,name=leaf,proto3,oneof"`
}

func (*Expand_Expand) isExpand_Node() {}

func (*Expand_Leaf) isExpand_Node() {}

// ExpandLeaf is the leaf node of an Expand tree and can be either a set of Subjects or a set of Values.
type ExpandLeaf struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Type:
	//
	//	*ExpandLeaf_Subjects
	//	*ExpandLeaf_Values
	//	*ExpandLeaf_Value
	Type          isExpandLeaf_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExpandLeaf) Reset() {
	*x = ExpandLeaf{}
	mi := &file_base_v1_base_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ExpandLeaf) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ExpandLeaf) ProtoMessage() {}

func (x *ExpandLeaf) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[31]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ExpandLeaf.ProtoReflect.Descriptor instead.
func (*ExpandLeaf) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{31}
}

func (x *ExpandLeaf) GetType() isExpandLeaf_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *ExpandLeaf) GetSubjects() *Subjects {
	if x != nil {
		if x, ok := x.Type.(*ExpandLeaf_Subjects); ok {
			return x.Subjects
		}
	}
	return nil
}

func (x *ExpandLeaf) GetValues() *Values {
	if x != nil {
		if x, ok := x.Type.(*ExpandLeaf_Values); ok {
			return x.Values
		}
	}
	return nil
}

func (x *ExpandLeaf) GetValue() *anypb.Any {
	if x != nil {
		if x, ok := x.Type.(*ExpandLeaf_Value); ok {
			return x.Value
		}
	}
	return nil
}

type isExpandLeaf_Type interface {
	isExpandLeaf_Type()
}

type ExpandLeaf_Subjects struct {
	// subjects are used when the leaf is a set of subjects.
	Subjects *Subjects `protobuf:"bytes,1,opt,name=subjects,proto3,oneof"`
}

type ExpandLeaf_Values struct {
	// values are used when the leaf node is a set of values.
	Values *Values `protobuf:"bytes,2,opt,name=values,proto3,oneof"`
}

type ExpandLeaf_Value struct {
	// value is used when the leaf node is a single value.
	Value *anypb.Any `protobuf:"bytes,3,opt,name=value,proto3,oneof"`
}

func (*ExpandLeaf_Subjects) isExpandLeaf_Type() {}

func (*ExpandLeaf_Values) isExpandLeaf_Type() {}

func (*ExpandLeaf_Value) isExpandLeaf_Type() {}

type Values struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        map[string]*anypb.Any  `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Values) Reset() {
	*x = Values{}
	mi := &file_base_v1_base_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Values) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Values) ProtoMessage() {}

func (x *Values) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[32]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Values.ProtoReflect.Descriptor instead.
func (*Values) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{32}
}

func (x *Values) GetValues() map[string]*anypb.Any {
	if x != nil {
		return x.Values
	}
	return nil
}

// Subjects holds a repeated field of Subject type.
type Subjects struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Subjects      []*Subject             `protobuf:"bytes,1,rep,name=subjects,proto3" json:"subjects,omitempty"` // A list of subjects.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Subjects) Reset() {
	*x = Subjects{}
	mi := &file_base_v1_base_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Subjects) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Subjects) ProtoMessage() {}

func (x *Subjects) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[33]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Subjects.ProtoReflect.Descriptor instead.
func (*Subjects) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{33}
}

func (x *Subjects) GetSubjects() []*Subject {
	if x != nil {
		return x.Subjects
	}
	return nil
}

// Tenant represents a tenant with an id, a name, and a timestamp indicating when it was created.
type Tenant struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`                 // The ID of the tenant.
	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`             // The name of the tenant.
	CreatedAt     *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=created_at,proto3" json:"created_at,omitempty"` // The time at which the tenant was created.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Tenant) Reset() {
	*x = Tenant{}
	mi := &file_base_v1_base_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Tenant) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Tenant) ProtoMessage() {}

func (x *Tenant) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[34]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Tenant.ProtoReflect.Descriptor instead.
func (*Tenant) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{34}
}

func (x *Tenant) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *Tenant) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Tenant) GetCreatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.CreatedAt
	}
	return nil
}

// DataChanges represent changes in data with a snap token and a list of data change objects.
type DataChanges struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SnapToken     string                 `protobuf:"bytes,1,opt,name=snap_token,proto3" json:"snap_token,omitempty"`     // The snapshot token.
	DataChanges   []*DataChange          `protobuf:"bytes,2,rep,name=data_changes,proto3" json:"data_changes,omitempty"` // The list of data changes.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DataChanges) Reset() {
	*x = DataChanges{}
	mi := &file_base_v1_base_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DataChanges) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DataChanges) ProtoMessage() {}

func (x *DataChanges) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[35]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DataChanges.ProtoReflect.Descriptor instead.
func (*DataChanges) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{35}
}

func (x *DataChanges) GetSnapToken() string {
	if x != nil {
		return x.SnapToken
	}
	return ""
}

func (x *DataChanges) GetDataChanges() []*DataChange {
	if x != nil {
		return x.DataChanges
	}
	return nil
}

// DataChange represents a single change in data, with an operation type and the actual change which could be a tuple or an attribute.
type DataChange struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	Operation DataChange_Operation   `protobuf:"varint,1,opt,name=operation,proto3,enum=base.v1.DataChange_Operation" json:"operation,omitempty"` // The operation type.
	// Types that are valid to be assigned to Type:
	//
	//	*DataChange_Tuple
	//	*DataChange_Attribute
	Type          isDataChange_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DataChange) Reset() {
	*x = DataChange{}
	mi := &file_base_v1_base_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DataChange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DataChange) ProtoMessage() {}

func (x *DataChange) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[36]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DataChange.ProtoReflect.Descriptor instead.
func (*DataChange) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{36}
}

func (x *DataChange) GetOperation() DataChange_Operation {
	if x != nil {
		return x.Operation
	}
	return DataChange_OPERATION_UNSPECIFIED
}

func (x *DataChange) GetType() isDataChange_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *DataChange) GetTuple() *Tuple {
	if x != nil {
		if x, ok := x.Type.(*DataChange_Tuple); ok {
			return x.Tuple
		}
	}
	return nil
}

func (x *DataChange) GetAttribute() *Attribute {
	if x != nil {
		if x, ok := x.Type.(*DataChange_Attribute); ok {
			return x.Attribute
		}
	}
	return nil
}

type isDataChange_Type interface {
	isDataChange_Type()
}

type DataChange_Tuple struct {
	Tuple *Tuple `protobuf:"bytes,2,opt,name=tuple,proto3,oneof"` // If the change is a tuple.
}

type DataChange_Attribute struct {
	Attribute *Attribute `protobuf:"bytes,3,opt,name=attribute,proto3,oneof"` // If the change is an attribute.
}

func (*DataChange_Tuple) isDataChange_Type() {}

func (*DataChange_Attribute) isDataChange_Type() {}

// Wrapper for a single string value.
type StringValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          string                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` // The string value.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StringValue) Reset() {
	*x = StringValue{}
	mi := &file_base_v1_base_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StringValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StringValue) ProtoMessage() {}

func (x *StringValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[37]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StringValue.ProtoReflect.Descriptor instead.
func (*StringValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{37}
}

func (x *StringValue) GetData() string {
	if x != nil {
		return x.Data
	}
	return ""
}

// Wrapper for a single integer value.
type IntegerValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          int32                  `protobuf:"varint,1,opt,name=data,proto3" json:"data,omitempty"` // The integer value.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *IntegerValue) Reset() {
	*x = IntegerValue{}
	mi := &file_base_v1_base_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *IntegerValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*IntegerValue) ProtoMessage() {}

func (x *IntegerValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[38]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use IntegerValue.ProtoReflect.Descriptor instead.
func (*IntegerValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{38}
}

func (x *IntegerValue) GetData() int32 {
	if x != nil {
		return x.Data
	}
	return 0
}

// Wrapper for a single double precision floating point value.
type DoubleValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          float64                `protobuf:"fixed64,1,opt,name=data,proto3" json:"data,omitempty"` // The double value.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DoubleValue) Reset() {
	*x = DoubleValue{}
	mi := &file_base_v1_base_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DoubleValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DoubleValue) ProtoMessage() {}

func (x *DoubleValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[39]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DoubleValue.ProtoReflect.Descriptor instead.
func (*DoubleValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{39}
}

func (x *DoubleValue) GetData() float64 {
	if x != nil {
		return x.Data
	}
	return 0
}

// Wrapper for a single boolean value.
type BooleanValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          bool                   `protobuf:"varint,1,opt,name=data,proto3" json:"data,omitempty"` // The boolean value.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BooleanValue) Reset() {
	*x = BooleanValue{}
	mi := &file_base_v1_base_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BooleanValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BooleanValue) ProtoMessage() {}

func (x *BooleanValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[40]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use BooleanValue.ProtoReflect.Descriptor instead.
func (*BooleanValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{40}
}

func (x *BooleanValue) GetData() bool {
	if x != nil {
		return x.Data
	}
	return false
}

// Wrapper for an array of strings.
type StringArrayValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []string               `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"` // The array of strings.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StringArrayValue) Reset() {
	*x = StringArrayValue{}
	mi := &file_base_v1_base_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StringArrayValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StringArrayValue) ProtoMessage() {}

func (x *StringArrayValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[41]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StringArrayValue.ProtoReflect.Descriptor instead.
func (*StringArrayValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{41}
}

func (x *StringArrayValue) GetData() []string {
	if x != nil {
		return x.Data
	}
	return nil
}

// Wrapper for an array of integers.
type IntegerArrayValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []int32                `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"` // The array of integers.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *IntegerArrayValue) Reset() {
	*x = IntegerArrayValue{}
	mi := &file_base_v1_base_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *IntegerArrayValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*IntegerArrayValue) ProtoMessage() {}

func (x *IntegerArrayValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[42]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use IntegerArrayValue.ProtoReflect.Descriptor instead.
func (*IntegerArrayValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{42}
}

func (x *IntegerArrayValue) GetData() []int32 {
	if x != nil {
		return x.Data
	}
	return nil
}

// Wrapper for an array of double precision floating point values.
type DoubleArrayValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []float64              `protobuf:"fixed64,1,rep,packed,name=data,proto3" json:"data,omitempty"` // The array of doubles.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DoubleArrayValue) Reset() {
	*x = DoubleArrayValue{}
	mi := &file_base_v1_base_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DoubleArrayValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DoubleArrayValue) ProtoMessage() {}

func (x *DoubleArrayValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[43]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DoubleArrayValue.ProtoReflect.Descriptor instead.
func (*DoubleArrayValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{43}
}

func (x *DoubleArrayValue) GetData() []float64 {
	if x != nil {
		return x.Data
	}
	return nil
}

// Wrapper for an array of booleans.
type BooleanArrayValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []bool                 `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"` // The array of booleans.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BooleanArrayValue) Reset() {
	*x = BooleanArrayValue{}
	mi := &file_base_v1_base_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BooleanArrayValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BooleanArrayValue) ProtoMessage() {}

func (x *BooleanArrayValue) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[44]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use BooleanArrayValue.ProtoReflect.Descriptor instead.
func (*BooleanArrayValue) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{44}
}

func (x *BooleanArrayValue) GetData() []bool {
	if x != nil {
		return x.Data
	}
	return nil
}

// DataBundle is a message representing a bundle of data, which includes a name,
// a list of arguments, and a series of operations.
type DataBundle struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// 'name' is a simple string field representing the name of the DataBundle.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// 'arguments' is a repeated field, which means it can contain multiple strings.
	// These are used to store a list of arguments related to the DataBundle.
	Arguments []string `protobuf:"bytes,2,rep,name=arguments,proto3" json:"arguments,omitempty"`
	// 'operations' is a repeated field containing multiple Operation messages.
	// Each Operation represents a specific action or set of actions to be performed.
	Operations    []*Operation `protobuf:"bytes,3,rep,name=operations,proto3" json:"operations,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DataBundle) Reset() {
	*x = DataBundle{}
	mi := &file_base_v1_base_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DataBundle) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DataBundle) ProtoMessage() {}

func (x *DataBundle) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[45]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DataBundle.ProtoReflect.Descriptor instead.
func (*DataBundle) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{45}
}

func (x *DataBundle) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *DataBundle) GetArguments() []string {
	if x != nil {
		return x.Arguments
	}
	return nil
}

func (x *DataBundle) GetOperations() []*Operation {
	if x != nil {
		return x.Operations
	}
	return nil
}

// Operation is a message representing a series of operations that can be performed.
// It includes fields for writing and deleting relationships and attributes.
type Operation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// 'relationships_write' is a repeated string field for storing relationship keys
	// that are to be written or created.
	RelationshipsWrite []string `protobuf:"bytes,1,rep,name=relationships_write,proto3" json:"relationships_write,omitempty"`
	// 'relationships_delete' is a repeated string field for storing relationship keys
	// that are to be deleted or removed.
	RelationshipsDelete []string `protobuf:"bytes,2,rep,name=relationships_delete,proto3" json:"relationships_delete,omitempty"`
	// 'attributes_write' is a repeated string field for storing attribute keys
	// that are to be written or created.
	AttributesWrite []string `protobuf:"bytes,3,rep,name=attributes_write,proto3" json:"attributes_write,omitempty"`
	// 'attributes_delete' is a repeated string field for storing attribute keys
	// that are to be deleted or removed.
	AttributesDelete []string `protobuf:"bytes,4,rep,name=attributes_delete,proto3" json:"attributes_delete,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *Operation) Reset() {
	*x = Operation{}
	mi := &file_base_v1_base_proto_msgTypes[46]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Operation) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Operation) ProtoMessage() {}

func (x *Operation) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[46]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Operation.ProtoReflect.Descriptor instead.
func (*Operation) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{46}
}

func (x *Operation) GetRelationshipsWrite() []string {
	if x != nil {
		return x.RelationshipsWrite
	}
	return nil
}

func (x *Operation) GetRelationshipsDelete() []string {
	if x != nil {
		return x.RelationshipsDelete
	}
	return nil
}

func (x *Operation) GetAttributesWrite() []string {
	if x != nil {
		return x.AttributesWrite
	}
	return nil
}

func (x *Operation) GetAttributesDelete() []string {
	if x != nil {
		return x.AttributesDelete
	}
	return nil
}

// Partials contains the write, update and delete definitions
type Partials struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Write         []string               `protobuf:"bytes,1,rep,name=write,proto3" json:"write,omitempty"`
	Delete        []string               `protobuf:"bytes,2,rep,name=delete,proto3" json:"delete,omitempty"`
	Update        []string               `protobuf:"bytes,3,rep,name=update,proto3" json:"update,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Partials) Reset() {
	*x = Partials{}
	mi := &file_base_v1_base_proto_msgTypes[47]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Partials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Partials) ProtoMessage() {}

func (x *Partials) ProtoReflect() protoreflect.Message {
	mi := &file_base_v1_base_proto_msgTypes[47]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Partials.ProtoReflect.Descriptor instead.
func (*Partials) Descriptor() ([]byte, []int) {
	return file_base_v1_base_proto_rawDescGZIP(), []int{47}
}

func (x *Partials) GetWrite() []string {
	if x != nil {
		return x.Write
	}
	return nil
}

func (x *Partials) GetDelete() []string {
	if x != nil {
		return x.Delete
	}
	return nil
}

func (x *Partials) GetUpdate() []string {
	if x != nil {
		return x.Update
	}
	return nil
}

var File_base_v1_base_proto protoreflect.FileDescriptor

const file_base_v1_base_proto_rawDesc = "" +
	"\n" +
	"\x12base/v1/base.proto\x12\abase.v1\x1a&google/api/expr/v1alpha1/checked.proto\x1a\x19google/protobuf/any.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x17validate/validate.proto\"\x92\x01\n" +
	"\aContext\x12&\n" +
	"\x06tuples\x18\x01 \x03(\v2\x0e.base.v1.TupleR\x06tuples\x122\n" +
	"\n" +
	"attributes\x18\x02 \x03(\v2\x12.base.v1.AttributeR\n" +
	"attributes\x12+\n" +
	"\x04data\x18\x03 \x01(\v2\x17.google.protobuf.StructR\x04data\"{\n" +
	"\x05Child\x12-\n" +
	"\x04leaf\x18\x01 \x01(\v2\r.base.v1.LeafB\b\xfaB\x05\x8a\x01\x02\x10\x01H\x00R\x04leaf\x126\n" +
	"\arewrite\x18\x02 \x01(\v2\x10.base.v1.RewriteB\b\xfaB\x05\x8a\x01\x02\x10\x01H\x00R\arewriteB\v\n" +
	"\x04type\x12\x03\xf8B\x01\"\xbb\x02\n" +
	"\x04Leaf\x12P\n" +
	"\x11computed_user_set\x18\x01 \x01(\v2\x18.base.v1.ComputedUserSetB\b\xfaB\x05\x8a\x01\x02\x10\x01H\x00R\x0fcomputedUserSet\x12N\n" +
	"\x11tuple_to_user_set\x18\x02 \x01(\v2\x17.base.v1.TupleToUserSetB\b\xfaB\x05\x8a\x01\x02\x10\x01H\x00R\x0etupleToUserSet\x12U\n" +
	"\x12computed_attribute\x18\x03 \x01(\v2\x1a.base.v1.ComputedAttributeB\b\xfaB\x05\x8a\x01\x02\x10\x01H\x00R\x11computedAttribute\x12-\n" +
	"\x04call\x18\x04 \x01(\v2\r.base.v1.CallB\b\xfaB\x05\x8a\x01\x02\x10\x01H\x00R\x04callB\v\n" +
	"\x04type\x12\x03\xf8B\x01\"\xf0\x01\n" +
	"\aRewrite\x12G\n" +
	"\x11rewrite_operation\x18\x01 \x01(\x0e2\x1a.base.v1.Rewrite.OperationR\x10rewriteOperation\x12*\n" +
	"\bchildren\x18\x02 \x03(\v2\x0e.base.v1.ChildR\bchildren\"p\n" +
	"\tOperation\x12\x19\n" +
	"\x15OPERATION_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fOPERATION_UNION\x10\x01\x12\x1a\n" +
	"\x16OPERATION_INTERSECTION\x10\x02\x12\x17\n" +
	"\x13OPERATION_EXCLUSION\x10\x03\"\x8d\x05\n" +
	"\x10SchemaDefinition\x12_\n" +
	"\x12entity_definitions\x18\x01 \x03(\v20.base.v1.SchemaDefinition.EntityDefinitionsEntryR\x11entityDefinitions\x12Y\n" +
	"\x10rule_definitions\x18\x02 \x03(\v2..base.v1.SchemaDefinition.RuleDefinitionsEntryR\x0fruleDefinitions\x12I\n" +
	"\n" +
	"references\x18\x03 \x03(\v2).base.v1.SchemaDefinition.ReferencesEntryR\n" +
	"references\x1a_\n" +
	"\x16EntityDefinitionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12/\n" +
	"\x05value\x18\x02 \x01(\v2\x19.base.v1.EntityDefinitionR\x05value:\x028\x01\x1a[\n" +
	"\x14RuleDefinitionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12-\n" +
	"\x05value\x18\x02 \x01(\v2\x17.base.v1.RuleDefinitionR\x05value:\x028\x01\x1ab\n" +
	"\x0fReferencesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x129\n" +
	"\x05value\x18\x02 \x01(\x0e2#.base.v1.SchemaDefinition.ReferenceR\x05value:\x028\x01\"P\n" +
	"\tReference\x12\x19\n" +
	"\x15REFERENCE_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10REFERENCE_ENTITY\x10\x01\x12\x12\n" +
	"\x0eREFERENCE_RULE\x10\x02\"\xdc\x06\n" +
	"\x10EntityDefinition\x12.\n" +
	"\x04name\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04name\x12F\n" +
	"\trelations\x18\x02 \x03(\v2(.base.v1.EntityDefinition.RelationsEntryR\trelations\x12L\n" +
	"\vpermissions\x18\x03 \x03(\v2*.base.v1.EntityDefinition.PermissionsEntryR\vpermissions\x12I\n" +
	"\n" +
	"attributes\x18\x04 \x03(\v2).base.v1.EntityDefinition.AttributesEntryR\n" +
	"attributes\x12I\n" +
	"\n" +
	"references\x18\x05 \x03(\v2).base.v1.EntityDefinition.ReferencesEntryR\n" +
	"references\x1aY\n" +
	"\x0eRelationsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x121\n" +
	"\x05value\x18\x02 \x01(\v2\x1b.base.v1.RelationDefinitionR\x05value:\x028\x01\x1a]\n" +
	"\x10PermissionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x123\n" +
	"\x05value\x18\x02 \x01(\v2\x1d.base.v1.PermissionDefinitionR\x05value:\x028\x01\x1a[\n" +
	"\x0fAttributesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x122\n" +
	"\x05value\x18\x02 \x01(\v2\x1c.base.v1.AttributeDefinitionR\x05value:\x028\x01\x1ab\n" +
	"\x0fReferencesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x129\n" +
	"\x05value\x18\x02 \x01(\x0e2#.base.v1.EntityDefinition.ReferenceR\x05value:\x028\x01\"q\n" +
	"\tReference\x12\x19\n" +
	"\x15REFERENCE_UNSPECIFIED\x10\x00\x12\x16\n" +
	"\x12REFERENCE_RELATION\x10\x01\x12\x18\n" +
	"\x14REFERENCE_PERMISSION\x10\x02\x12\x17\n" +
	"\x13REFERENCE_ATTRIBUTE\x10\x03\"\xa3\x02\n" +
	"\x0eRuleDefinition\x12.\n" +
	"\x04name\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04name\x12D\n" +
	"\targuments\x18\x02 \x03(\v2&.base.v1.RuleDefinition.ArgumentsEntryR\targuments\x12E\n" +
	"\n" +
	"expression\x18\x03 \x01(\v2%.google.api.expr.v1alpha1.CheckedExprR\n" +
	"expression\x1aT\n" +
	"\x0eArgumentsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12,\n" +
	"\x05value\x18\x02 \x01(\x0e2\x16.base.v1.AttributeTypeR\x05value:\x028\x01\"q\n" +
	"\x13AttributeDefinition\x12.\n" +
	"\x04name\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04name\x12*\n" +
	"\x04type\x18\x02 \x01(\x0e2\x16.base.v1.AttributeTypeR\x04type\"\x91\x01\n" +
	"\x12RelationDefinition\x12.\n" +
	"\x04name\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04name\x12K\n" +
	"\x13relation_references\x18\x02 \x03(\v2\x1a.base.v1.RelationReferenceR\x12relationReferences\"l\n" +
	"\x14PermissionDefinition\x12.\n" +
	"\x04name\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04name\x12$\n" +
	"\x05child\x18\x02 \x01(\v2\x0e.base.v1.ChildR\x05child\"~\n" +
	"\x11RelationReference\x12.\n" +
	"\x04type\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04type\x129\n" +
	"\brelation\x18\x02 \x01(\tB\x1d\xfaB\x1ar\x18(@2\x11^[a-zA-Z_]{1,64}$\xd0\x01\x01R\brelation\"l\n" +
	"\bEntrance\x12.\n" +
	"\x04type\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04type\x120\n" +
	"\x05value\x18\x02 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x05value\"_\n" +
	"\bArgument\x12K\n" +
	"\x12computed_attribute\x18\x01 \x01(\v2\x1a.base.v1.ComputedAttributeH\x00R\x11computedAttributeB\x06\n" +
	"\x04type\"T\n" +
	"\x04Call\x12\x1b\n" +
	"\trule_name\x18\x01 \x01(\tR\bruleName\x12/\n" +
	"\targuments\x18\x02 \x03(\v2\x11.base.v1.ArgumentR\targuments\"C\n" +
	"\x11ComputedAttribute\x12.\n" +
	"\x04name\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04name\"I\n" +
	"\x0fComputedUserSet\x126\n" +
	"\brelation\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\brelation\"u\n" +
	"\x0eTupleToUserSet\x12-\n" +
	"\btupleSet\x18\x01 \x01(\v2\x11.base.v1.TupleSetR\btupleSet\x124\n" +
	"\bcomputed\x18\x02 \x01(\v2\x18.base.v1.ComputedUserSetR\bcomputed\"B\n" +
	"\bTupleSet\x126\n" +
	"\brelation\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\brelation\"\xa8\x01\n" +
	"\x05Tuple\x121\n" +
	"\x06entity\x18\x01 \x01(\v2\x0f.base.v1.EntityB\b\xfaB\x05\x8a\x01\x02\x10\x01R\x06entity\x126\n" +
	"\brelation\x18\x02 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\brelation\x124\n" +
	"\asubject\x18\x03 \x01(\v2\x10.base.v1.SubjectB\b\xfaB\x05\x8a\x01\x02\x10\x01R\asubject\"\x88\x01\n" +
	"\tAttribute\x121\n" +
	"\x06entity\x18\x01 \x01(\v2\x0f.base.v1.EntityB\b\xfaB\x05\x8a\x01\x02\x10\x01R\x06entity\x12\x1c\n" +
	"\tattribute\x18\x02 \x01(\tR\tattribute\x12*\n" +
	"\x05value\x18\x03 \x01(\v2\x14.google.protobuf.AnyR\x05value\"0\n" +
	"\x06Tuples\x12&\n" +
	"\x06tuples\x18\x01 \x03(\v2\x0e.base.v1.TupleR\x06tuples\"@\n" +
	"\n" +
	"Attributes\x122\n" +
	"\n" +
	"attributes\x18\x01 \x03(\v2\x12.base.v1.AttributeR\n" +
	"attributes\"u\n" +
	"\x06Entity\x12.\n" +
	"\x04type\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04type\x12;\n" +
	"\x02id\x18\x02 \x01(\tB+\xfaB(r&(\x80\x012!^([a-zA-Z0-9_\\-@\\.:+]{1,128}|\\*)$R\x02id\"~\n" +
	"\x11EntityAndRelation\x121\n" +
	"\x06entity\x18\x01 \x01(\v2\x0f.base.v1.EntityB\b\xfaB\x05\x8a\x01\x02\x10\x01R\x06entity\x126\n" +
	"\brelation\x18\x02 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\brelation\"\xb1\x01\n" +
	"\aSubject\x12.\n" +
	"\x04type\x18\x01 \x01(\tB\x1a\xfaB\x17r\x15(@2\x11^[a-zA-Z_]{1,64}$R\x04type\x12;\n" +
	"\x02id\x18\x02 \x01(\tB+\xfaB(r&(\x80\x012!^([a-zA-Z0-9_\\-@\\.:+]{1,128}|\\*)$R\x02id\x129\n" +
	"\brelation\x18\x03 \x01(\tB\x1d\xfaB\x1ar\x18(@2\x11^[a-zA-Z_]{1,64}$\xd0\x01\x01R\brelation\"`\n" +
	"\x0fAttributeFilter\x12-\n" +
	"\x06entity\x18\x01 \x01(\v2\x15.base.v1.EntityFilterR\x06entity\x12\x1e\n" +
	"\n" +
	"attributes\x18\x02 \x03(\tR\n" +
	"attributes\"\xa9\x01\n" +
	"\vTupleFilter\x12-\n" +
	"\x06entity\x18\x01 \x01(\v2\x15.base.v1.EntityFilterR\x06entity\x129\n" +
	"\brelation\x18\x02 \x01(\tB\x1d\xfaB\x1ar\x18(@2\x11^[a-zA-Z_]{1,64}$\xd0\x01\x01R\brelation\x120\n" +
	"\asubject\x18\x03 \x01(\v2\x16.base.v1.SubjectFilterR\asubject\"4\n" +
	"\fEntityFilter\x12\x12\n" +
	"\x04type\x18\x01 \x01(\tR\x04type\x12\x10\n" +
	"\x03ids\x18\x02 \x03(\tR\x03ids\"p\n" +
	"\rSubjectFilter\x12\x12\n" +
	"\x04type\x18\x01 \x01(\tR\x04type\x12\x10\n" +
	"\x03ids\x18\x02 \x03(\tR\x03ids\x129\n" +
	"\brelation\x18\x03 \x01(\tB\x1d\xfaB\x1ar\x18(@2\x11^[a-zA-Z_]{1,64}$\xd0\x01\x01R\brelation\"\xf0\x01\n" +
	"\x0eExpandTreeNode\x12?\n" +
	"\toperation\x18\x01 \x01(\x0e2!.base.v1.ExpandTreeNode.OperationR\toperation\x12+\n" +
	"\bchildren\x18\x02 \x03(\v2\x0f.base.v1.ExpandR\bchildren\"p\n" +
	"\tOperation\x12\x19\n" +
	"\x15OPERATION_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fOPERATION_UNION\x10\x01\x12\x1a\n" +
	"\x16OPERATION_INTERSECTION\x10\x02\x12\x17\n" +
	"\x13OPERATION_EXCLUSION\x10\x03\"\xe8\x01\n" +
	"\x06Expand\x12'\n" +
	"\x06entity\x18\x01 \x01(\v2\x0f.base.v1.EntityR\x06entity\x12\x1e\n" +
	"\n" +
	"permission\x18\x02 \x01(\tR\n" +
	"permission\x12/\n" +
	"\targuments\x18\x03 \x03(\v2\x11.base.v1.ArgumentR\targuments\x121\n" +
	"\x06expand\x18\x04 \x01(\v2\x17.base.v1.ExpandTreeNodeH\x00R\x06expand\x12)\n" +
	"\x04leaf\x18\x05 \x01(\v2\x13.base.v1.ExpandLeafH\x00R\x04leafB\x06\n" +
	"\x04node\"\xa3\x01\n" +
	"\n" +
	"ExpandLeaf\x12/\n" +
	"\bsubjects\x18\x01 \x01(\v2\x11.base.v1.SubjectsH\x00R\bsubjects\x12)\n" +
	"\x06values\x18\x02 \x01(\v2\x0f.base.v1.ValuesH\x00R\x06values\x12,\n" +
	"\x05value\x18\x03 \x01(\v2\x14.google.protobuf.AnyH\x00R\x05valueB\v\n" +
	"\x04type\x12\x03\xf8B\x01\"\x8e\x01\n" +
	"\x06Values\x123\n" +
	"\x06values\x18\x01 \x03(\v2\x1b.base.v1.Values.ValuesEntryR\x06values\x1aO\n" +
	"\vValuesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\"8\n" +
	"\bSubjects\x12,\n" +
	"\bsubjects\x18\x01 \x03(\v2\x10.base.v1.SubjectR\bsubjects\"h\n" +
	"\x06Tenant\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12:\n" +
	"\n" +
	"created_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"created_at\"f\n" +
	"\vDataChanges\x12\x1e\n" +
	"\n" +
	"snap_token\x18\x01 \x01(\tR\n" +
	"snap_token\x127\n" +
	"\fdata_changes\x18\x02 \x03(\v2\x13.base.v1.DataChangeR\fdata_changes\"\x86\x02\n" +
	"\n" +
	"DataChange\x12;\n" +
	"\toperation\x18\x01 \x01(\x0e2\x1d.base.v1.DataChange.OperationR\toperation\x12&\n" +
	"\x05tuple\x18\x02 \x01(\v2\x0e.base.v1.TupleH\x00R\x05tuple\x122\n" +
	"\tattribute\x18\x03 \x01(\v2\x12.base.v1.AttributeH\x00R\tattribute\"R\n" +
	"\tOperation\x12\x19\n" +
	"\x15OPERATION_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10OPERATION_CREATE\x10\x01\x12\x14\n" +
	"\x10OPERATION_DELETE\x10\x02B\v\n" +
	"\x04type\x12\x03\xf8B\x01\"!\n" +
	"\vStringValue\x12\x12\n" +
	"\x04data\x18\x01 \x01(\tR\x04data\"\"\n" +
	"\fIntegerValue\x12\x12\n" +
	"\x04data\x18\x01 \x01(\x05R\x04data\"!\n" +
	"\vDoubleValue\x12\x12\n" +
	"\x04data\x18\x01 \x01(\x01R\x04data\"\"\n" +
	"\fBooleanValue\x12\x12\n" +
	"\x04data\x18\x01 \x01(\bR\x04data\"&\n" +
	"\x10StringArrayValue\x12\x12\n" +
	"\x04data\x18\x01 \x03(\tR\x04data\"'\n" +
	"\x11IntegerArrayValue\x12\x12\n" +
	"\x04data\x18\x01 \x03(\x05R\x04data\"&\n" +
	"\x10DoubleArrayValue\x12\x12\n" +
	"\x04data\x18\x01 \x03(\x01R\x04data\"'\n" +
	"\x11BooleanArrayValue\x12\x12\n" +
	"\x04data\x18\x01 \x03(\bR\x04data\"r\n" +
	"\n" +
	"DataBundle\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n" +
	"\targuments\x18\x02 \x03(\tR\targuments\x122\n" +
	"\n" +
	"operations\x18\x03 \x03(\v2\x12.base.v1.OperationR\n" +
	"operations\"\xcb\x01\n" +
	"\tOperation\x120\n" +
	"\x13relationships_write\x18\x01 \x03(\tR\x13relationships_write\x122\n" +
	"\x14relationships_delete\x18\x02 \x03(\tR\x14relationships_delete\x12*\n" +
	"\x10attributes_write\x18\x03 \x03(\tR\x10attributes_write\x12,\n" +
	"\x11attributes_delete\x18\x04 \x03(\tR\x11attributes_delete\"P\n" +
	"\bPartials\x12\x14\n" +
	"\x05write\x18\x01 \x03(\tR\x05write\x12\x16\n" +
	"\x06delete\x18\x02 \x03(\tR\x06delete\x12\x16\n" +
	"\x06update\x18\x03 \x03(\tR\x06update*^\n" +
	"\vCheckResult\x12\x1c\n" +
	"\x18CHECK_RESULT_UNSPECIFIED\x10\x00\x12\x18\n" +
	"\x14CHECK_RESULT_ALLOWED\x10\x01\x12\x17\n" +
	"\x13CHECK_RESULT_DENIED\x10\x02*\xa3\x02\n" +
	"\rAttributeType\x12\x1e\n" +
	"\x1aATTRIBUTE_TYPE_UNSPECIFIED\x10\x00\x12\x1a\n" +
	"\x16ATTRIBUTE_TYPE_BOOLEAN\x10\x01\x12 \n" +
	"\x1cATTRIBUTE_TYPE_BOOLEAN_ARRAY\x10\x02\x12\x19\n" +
	"\x15ATTRIBUTE_TYPE_STRING\x10\x03\x12\x1f\n" +
	"\x1bATTRIBUTE_TYPE_STRING_ARRAY\x10\x04\x12\x1a\n" +
	"\x16ATTRIBUTE_TYPE_INTEGER\x10\x05\x12 \n" +
	"\x1cATTRIBUTE_TYPE_INTEGER_ARRAY\x10\x06\x12\x19\n" +
	"\x15ATTRIBUTE_TYPE_DOUBLE\x10\a\x12\x1f\n" +
	"\x1bATTRIBUTE_TYPE_DOUBLE_ARRAY\x10\bB\x87\x01\n" +
	"\vcom.base.v1B\tBaseProtoP\x01Z0github.com/Permify/permify/pkg/pb/base/v1;basev1\xa2\x02\x03BXX\xaa\x02\aBase.V1\xca\x02\aBase\\V1\xe2\x02\x13Base\\V1\\GPBMetadata\xea\x02\bBase::V1b\x06proto3"

var (
	file_base_v1_base_proto_rawDescOnce sync.Once
	file_base_v1_base_proto_rawDescData []byte
)

func file_base_v1_base_proto_rawDescGZIP() []byte {
	file_base_v1_base_proto_rawDescOnce.Do(func() {
		file_base_v1_base_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_base_v1_base_proto_rawDesc), len(file_base_v1_base_proto_rawDesc)))
	})
	return file_base_v1_base_proto_rawDescData
}

var file_base_v1_base_proto_enumTypes = make([]protoimpl.EnumInfo, 7)
var file_base_v1_base_proto_msgTypes = make([]protoimpl.MessageInfo, 57)
var file_base_v1_base_proto_goTypes = []any{
	(CheckResult)(0),                // 0: base.v1.CheckResult
	(AttributeType)(0),              // 1: base.v1.AttributeType
	(Rewrite_Operation)(0),          // 2: base.v1.Rewrite.Operation
	(SchemaDefinition_Reference)(0), // 3: base.v1.SchemaDefinition.Reference
	(EntityDefinition_Reference)(0), // 4: base.v1.EntityDefinition.Reference
	(ExpandTreeNode_Operation)(0),   // 5: base.v1.ExpandTreeNode.Operation
	(DataChange_Operation)(0),       // 6: base.v1.DataChange.Operation
	(*Context)(nil),                 // 7: base.v1.Context
	(*Child)(nil),                   // 8: base.v1.Child
	(*Leaf)(nil),                    // 9: base.v1.Leaf
	(*Rewrite)(nil),                 // 10: base.v1.Rewrite
	(*SchemaDefinition)(nil),        // 11: base.v1.SchemaDefinition
	(*EntityDefinition)(nil),        // 12: base.v1.EntityDefinition
	(*RuleDefinition)(nil),          // 13: base.v1.RuleDefinition
	(*AttributeDefinition)(nil),     // 14: base.v1.AttributeDefinition
	(*RelationDefinition)(nil),      // 15: base.v1.RelationDefinition
	(*PermissionDefinition)(nil),    // 16: base.v1.PermissionDefinition
	(*RelationReference)(nil),       // 17: base.v1.RelationReference
	(*Entrance)(nil),                // 18: base.v1.Entrance
	(*Argument)(nil),                // 19: base.v1.Argument
	(*Call)(nil),                    // 20: base.v1.Call
	(*ComputedAttribute)(nil),       // 21: base.v1.ComputedAttribute
	(*ComputedUserSet)(nil),         // 22: base.v1.ComputedUserSet
	(*TupleToUserSet)(nil),          // 23: base.v1.TupleToUserSet
	(*TupleSet)(nil),                // 24: base.v1.TupleSet
	(*Tuple)(nil),                   // 25: base.v1.Tuple
	(*Attribute)(nil),               // 26: base.v1.Attribute
	(*Tuples)(nil),                  // 27: base.v1.Tuples
	(*Attributes)(nil),              // 28: base.v1.Attributes
	(*Entity)(nil),                  // 29: base.v1.Entity
	(*EntityAndRelation)(nil),       // 30: base.v1.EntityAndRelation
	(*Subject)(nil),                 // 31: base.v1.Subject
	(*AttributeFilter)(nil),         // 32: base.v1.AttributeFilter
	(*TupleFilter)(nil),             // 33: base.v1.TupleFilter
	(*EntityFilter)(nil),            // 34: base.v1.EntityFilter
	(*SubjectFilter)(nil),           // 35: base.v1.SubjectFilter
	(*ExpandTreeNode)(nil),          // 36: base.v1.ExpandTreeNode
	(*Expand)(nil),                  // 37: base.v1.Expand
	(*ExpandLeaf)(nil),              // 38: base.v1.ExpandLeaf
	(*Values)(nil),                  // 39: base.v1.Values
	(*Subjects)(nil),                // 40: base.v1.Subjects
	(*Tenant)(nil),                  // 41: base.v1.Tenant
	(*DataChanges)(nil),             // 42: base.v1.DataChanges
	(*DataChange)(nil),              // 43: base.v1.DataChange
	(*StringValue)(nil),             // 44: base.v1.StringValue
	(*IntegerValue)(nil),            // 45: base.v1.IntegerValue
	(*DoubleValue)(nil),             // 46: base.v1.DoubleValue
	(*BooleanValue)(nil),            // 47: base.v1.BooleanValue
	(*StringArrayValue)(nil),        // 48: base.v1.StringArrayValue
	(*IntegerArrayValue)(nil),       // 49: base.v1.IntegerArrayValue
	(*DoubleArrayValue)(nil),        // 50: base.v1.DoubleArrayValue
	(*BooleanArrayValue)(nil),       // 51: base.v1.BooleanArrayValue
	(*DataBundle)(nil),              // 52: base.v1.DataBundle
	(*Operation)(nil),               // 53: base.v1.Operation
	(*Partials)(nil),                // 54: base.v1.Partials
	nil,                             // 55: base.v1.SchemaDefinition.EntityDefinitionsEntry
	nil,                             // 56: base.v1.SchemaDefinition.RuleDefinitionsEntry
	nil,                             // 57: base.v1.SchemaDefinition.ReferencesEntry
	nil,                             // 58: base.v1.EntityDefinition.RelationsEntry
	nil,                             // 59: base.v1.EntityDefinition.PermissionsEntry
	nil,                             // 60: base.v1.EntityDefinition.AttributesEntry
	nil,                             // 61: base.v1.EntityDefinition.ReferencesEntry
	nil,                             // 62: base.v1.RuleDefinition.ArgumentsEntry
	nil,                             // 63: base.v1.Values.ValuesEntry
	(*structpb.Struct)(nil),         // 64: google.protobuf.Struct
	(*v1alpha1.CheckedExpr)(nil),    // 65: google.api.expr.v1alpha1.CheckedExpr
	(*anypb.Any)(nil),               // 66: google.protobuf.Any
	(*timestamppb.Timestamp)(nil),   // 67: google.protobuf.Timestamp
}
var file_base_v1_base_proto_depIdxs = []int32{
	25, // 0: base.v1.Context.tuples:type_name -> base.v1.Tuple
	26, // 1: base.v1.Context.attributes:type_name -> base.v1.Attribute
	64, // 2: base.v1.Context.data:type_name -> google.protobuf.Struct
	9,  // 3: base.v1.Child.leaf:type_name -> base.v1.Leaf
	10, // 4: base.v1.Child.rewrite:type_name -> base.v1.Rewrite
	22, // 5: base.v1.Leaf.computed_user_set:type_name -> base.v1.ComputedUserSet
	23, // 6: base.v1.Leaf.tuple_to_user_set:type_name -> base.v1.TupleToUserSet
	21, // 7: base.v1.Leaf.computed_attribute:type_name -> base.v1.ComputedAttribute
	20, // 8: base.v1.Leaf.call:type_name -> base.v1.Call
	2,  // 9: base.v1.Rewrite.rewrite_operation:type_name -> base.v1.Rewrite.Operation
	8,  // 10: base.v1.Rewrite.children:type_name -> base.v1.Child
	55, // 11: base.v1.SchemaDefinition.entity_definitions:type_name -> base.v1.SchemaDefinition.EntityDefinitionsEntry
	56, // 12: base.v1.SchemaDefinition.rule_definitions:type_name -> base.v1.SchemaDefinition.RuleDefinitionsEntry
	57, // 13: base.v1.SchemaDefinition.references:type_name -> base.v1.SchemaDefinition.ReferencesEntry
	58, // 14: base.v1.EntityDefinition.relations:type_name -> base.v1.EntityDefinition.RelationsEntry
	59, // 15: base.v1.EntityDefinition.permissions:type_name -> base.v1.EntityDefinition.PermissionsEntry
	60, // 16: base.v1.EntityDefinition.attributes:type_name -> base.v1.EntityDefinition.AttributesEntry
	61, // 17: base.v1.EntityDefinition.references:type_name -> base.v1.EntityDefinition.ReferencesEntry
	62, // 18: base.v1.RuleDefinition.arguments:type_name -> base.v1.RuleDefinition.ArgumentsEntry
	65, // 19: base.v1.RuleDefinition.expression:type_name -> google.api.expr.v1alpha1.CheckedExpr
	1,  // 20: base.v1.AttributeDefinition.type:type_name -> base.v1.AttributeType
	17, // 21: base.v1.RelationDefinition.relation_references:type_name -> base.v1.RelationReference
	8,  // 22: base.v1.PermissionDefinition.child:type_name -> base.v1.Child
	21, // 23: base.v1.Argument.computed_attribute:type_name -> base.v1.ComputedAttribute
	19, // 24: base.v1.Call.arguments:type_name -> base.v1.Argument
	24, // 25: base.v1.TupleToUserSet.tupleSet:type_name -> base.v1.TupleSet
	22, // 26: base.v1.TupleToUserSet.computed:type_name -> base.v1.ComputedUserSet
	29, // 27: base.v1.Tuple.entity:type_name -> base.v1.Entity
	31, // 28: base.v1.Tuple.subject:type_name -> base.v1.Subject
	29, // 29: base.v1.Attribute.entity:type_name -> base.v1.Entity
	66, // 30: base.v1.Attribute.value:type_name -> google.protobuf.Any
	25, // 31: base.v1.Tuples.tuples:type_name -> base.v1.Tuple
	26, // 32: base.v1.Attributes.attributes:type_name -> base.v1.Attribute
	29, // 33: base.v1.EntityAndRelation.entity:type_name -> base.v1.Entity
	34, // 34: base.v1.AttributeFilter.entity:type_name -> base.v1.EntityFilter
	34, // 35: base.v1.TupleFilter.entity:type_name -> base.v1.EntityFilter
	35, // 36: base.v1.TupleFilter.subject:type_name -> base.v1.SubjectFilter
	5,  // 37: base.v1.ExpandTreeNode.operation:type_name -> base.v1.ExpandTreeNode.Operation
	37, // 38: base.v1.ExpandTreeNode.children:type_name -> base.v1.Expand
	29, // 39: base.v1.Expand.entity:type_name -> base.v1.Entity
	19, // 40: base.v1.Expand.arguments:type_name -> base.v1.Argument
	36, // 41: base.v1.Expand.expand:type_name -> base.v1.ExpandTreeNode
	38, // 42: base.v1.Expand.leaf:type_name -> base.v1.ExpandLeaf
	40, // 43: base.v1.ExpandLeaf.subjects:type_name -> base.v1.Subjects
	39, // 44: base.v1.ExpandLeaf.values:type_name -> base.v1.Values
	66, // 45: base.v1.ExpandLeaf.value:type_name -> google.protobuf.Any
	63, // 46: base.v1.Values.values:type_name -> base.v1.Values.ValuesEntry
	31, // 47: base.v1.Subjects.subjects:type_name -> base.v1.Subject
	67, // 48: base.v1.Tenant.created_at:type_name -> google.protobuf.Timestamp
	43, // 49: base.v1.DataChanges.data_changes:type_name -> base.v1.DataChange
	6,  // 50: base.v1.DataChange.operation:type_name -> base.v1.DataChange.Operation
	25, // 51: base.v1.DataChange.tuple:type_name -> base.v1.Tuple
	26, // 52: base.v1.DataChange.attribute:type_name -> base.v1.Attribute
	53, // 53: base.v1.DataBundle.operations:type_name -> base.v1.Operation
	12, // 54: base.v1.SchemaDefinition.EntityDefinitionsEntry.value:type_name -> base.v1.EntityDefinition
	13, // 55: base.v1.SchemaDefinition.RuleDefinitionsEntry.value:type_name -> base.v1.RuleDefinition
	3,  // 56: base.v1.SchemaDefinition.ReferencesEntry.value:type_name -> base.v1.SchemaDefinition.Reference
	15, // 57: base.v1.EntityDefinition.RelationsEntry.value:type_name -> base.v1.RelationDefinition
	16, // 58: base.v1.EntityDefinition.PermissionsEntry.value:type_name -> base.v1.PermissionDefinition
	14, // 59: base.v1.EntityDefinition.AttributesEntry.value:type_name -> base.v1.AttributeDefinition
	4,  // 60: base.v1.EntityDefinition.ReferencesEntry.value:type_name -> base.v1.EntityDefinition.Reference
	1,  // 61: base.v1.RuleDefinition.ArgumentsEntry.value:type_name -> base.v1.AttributeType
	66, // 62: base.v1.Values.ValuesEntry.value:type_name -> google.protobuf.Any
	63, // [63:63] is the sub-list for method output_type
	63, // [63:63] is the sub-list for method input_type
	63, // [63:63] is the sub-list for extension type_name
	63, // [63:63] is the sub-list for extension extendee
	0,  // [0:63] is the sub-list for field type_name
}

func init() { file_base_v1_base_proto_init() }
func file_base_v1_base_proto_init() {
	if File_base_v1_base_proto != nil {
		return
	}
	file_base_v1_base_proto_msgTypes[1].OneofWrappers = []any{
		(*Child_Leaf)(nil),
		(*Child_Rewrite)(nil),
	}
	file_base_v1_base_proto_msgTypes[2].OneofWrappers = []any{
		(*Leaf_ComputedUserSet)(nil),
		(*Leaf_TupleToUserSet)(nil),
		(*Leaf_ComputedAttribute)(nil),
		(*Leaf_Call)(nil),
	}
	file_base_v1_base_proto_msgTypes[12].OneofWrappers = []any{
		(*Argument_ComputedAttribute)(nil),
	}
	file_base_v1_base_proto_msgTypes[30].OneofWrappers = []any{
		(*Expand_Expand)(nil),
		(*Expand_Leaf)(nil),
	}
	file_base_v1_base_proto_msgTypes[31].OneofWrappers = []any{
		(*ExpandLeaf_Subjects)(nil),
		(*ExpandLeaf_Values)(nil),
		(*ExpandLeaf_Value)(nil),
	}
	file_base_v1_base_proto_msgTypes[36].OneofWrappers = []any{
		(*DataChange_Tuple)(nil),
		(*DataChange_Attribute)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_base_v1_base_proto_rawDesc), len(file_base_v1_base_proto_rawDesc)),
			NumEnums:      7,
			NumMessages:   57,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_base_v1_base_proto_goTypes,
		DependencyIndexes: file_base_v1_base_proto_depIdxs,
		EnumInfos:         file_base_v1_base_proto_enumTypes,
		MessageInfos:      file_base_v1_base_proto_msgTypes,
	}.Build()
	File_base_v1_base_proto = out.File
	file_base_v1_base_proto_goTypes = nil
	file_base_v1_base_proto_depIdxs = nil
}
