// Code generated by protoc-gen-go. DO NOT EDIT.

package protocol

import (
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"

	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	structpb "google.golang.org/protobuf/types/known/structpb"
)

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)
)

type ConsistencyLevel int32

const (
	ConsistencyLevel_CONSISTENCY_LEVEL_UNSPECIFIED ConsistencyLevel = 0
	ConsistencyLevel_CONSISTENCY_LEVEL_ONE         ConsistencyLevel = 1
	ConsistencyLevel_CONSISTENCY_LEVEL_QUORUM      ConsistencyLevel = 2
	ConsistencyLevel_CONSISTENCY_LEVEL_ALL         ConsistencyLevel = 3
)

// Enum value maps for ConsistencyLevel.
var (
	ConsistencyLevel_name = map[int32]string{
		0: "CONSISTENCY_LEVEL_UNSPECIFIED",
		1: "CONSISTENCY_LEVEL_ONE",
		2: "CONSISTENCY_LEVEL_QUORUM",
		3: "CONSISTENCY_LEVEL_ALL",
	}
	ConsistencyLevel_value = map[string]int32{
		"CONSISTENCY_LEVEL_UNSPECIFIED": 0,
		"CONSISTENCY_LEVEL_ONE":         1,
		"CONSISTENCY_LEVEL_QUORUM":      2,
		"CONSISTENCY_LEVEL_ALL":         3,
	}
)

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

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

func (ConsistencyLevel) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_base_proto_enumTypes[0].Descriptor()
}

func (ConsistencyLevel) Type() protoreflect.EnumType {
	return &file_v1_base_proto_enumTypes[0]
}

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

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

type Filters_Operator int32

const (
	Filters_OPERATOR_UNSPECIFIED        Filters_Operator = 0
	Filters_OPERATOR_EQUAL              Filters_Operator = 1
	Filters_OPERATOR_NOT_EQUAL          Filters_Operator = 2
	Filters_OPERATOR_GREATER_THAN       Filters_Operator = 3
	Filters_OPERATOR_GREATER_THAN_EQUAL Filters_Operator = 4
	Filters_OPERATOR_LESS_THAN          Filters_Operator = 5
	Filters_OPERATOR_LESS_THAN_EQUAL    Filters_Operator = 6
	Filters_OPERATOR_AND                Filters_Operator = 7
	Filters_OPERATOR_OR                 Filters_Operator = 8
	Filters_OPERATOR_WITHIN_GEO_RANGE   Filters_Operator = 9
	Filters_OPERATOR_LIKE               Filters_Operator = 10
	Filters_OPERATOR_IS_NULL            Filters_Operator = 11
	Filters_OPERATOR_CONTAINS_ANY       Filters_Operator = 12
	Filters_OPERATOR_CONTAINS_ALL       Filters_Operator = 13
	Filters_OPERATOR_CONTAINS_NONE      Filters_Operator = 14
	Filters_OPERATOR_NOT                Filters_Operator = 15
)

// Enum value maps for Filters_Operator.
var (
	Filters_Operator_name = map[int32]string{
		0:  "OPERATOR_UNSPECIFIED",
		1:  "OPERATOR_EQUAL",
		2:  "OPERATOR_NOT_EQUAL",
		3:  "OPERATOR_GREATER_THAN",
		4:  "OPERATOR_GREATER_THAN_EQUAL",
		5:  "OPERATOR_LESS_THAN",
		6:  "OPERATOR_LESS_THAN_EQUAL",
		7:  "OPERATOR_AND",
		8:  "OPERATOR_OR",
		9:  "OPERATOR_WITHIN_GEO_RANGE",
		10: "OPERATOR_LIKE",
		11: "OPERATOR_IS_NULL",
		12: "OPERATOR_CONTAINS_ANY",
		13: "OPERATOR_CONTAINS_ALL",
		14: "OPERATOR_CONTAINS_NONE",
		15: "OPERATOR_NOT",
	}
	Filters_Operator_value = map[string]int32{
		"OPERATOR_UNSPECIFIED":        0,
		"OPERATOR_EQUAL":              1,
		"OPERATOR_NOT_EQUAL":          2,
		"OPERATOR_GREATER_THAN":       3,
		"OPERATOR_GREATER_THAN_EQUAL": 4,
		"OPERATOR_LESS_THAN":          5,
		"OPERATOR_LESS_THAN_EQUAL":    6,
		"OPERATOR_AND":                7,
		"OPERATOR_OR":                 8,
		"OPERATOR_WITHIN_GEO_RANGE":   9,
		"OPERATOR_LIKE":               10,
		"OPERATOR_IS_NULL":            11,
		"OPERATOR_CONTAINS_ANY":       12,
		"OPERATOR_CONTAINS_ALL":       13,
		"OPERATOR_CONTAINS_NONE":      14,
		"OPERATOR_NOT":                15,
	}
)

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

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

func (Filters_Operator) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_base_proto_enumTypes[1].Descriptor()
}

func (Filters_Operator) Type() protoreflect.EnumType {
	return &file_v1_base_proto_enumTypes[1]
}

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

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

type Vectors_VectorType int32

const (
	Vectors_VECTOR_TYPE_UNSPECIFIED Vectors_VectorType = 0
	Vectors_VECTOR_TYPE_SINGLE_FP32 Vectors_VectorType = 1
	Vectors_VECTOR_TYPE_MULTI_FP32  Vectors_VectorType = 2
)

// Enum value maps for Vectors_VectorType.
var (
	Vectors_VectorType_name = map[int32]string{
		0: "VECTOR_TYPE_UNSPECIFIED",
		1: "VECTOR_TYPE_SINGLE_FP32",
		2: "VECTOR_TYPE_MULTI_FP32",
	}
	Vectors_VectorType_value = map[string]int32{
		"VECTOR_TYPE_UNSPECIFIED": 0,
		"VECTOR_TYPE_SINGLE_FP32": 1,
		"VECTOR_TYPE_MULTI_FP32":  2,
	}
)

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

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

func (Vectors_VectorType) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_base_proto_enumTypes[2].Descriptor()
}

func (Vectors_VectorType) Type() protoreflect.EnumType {
	return &file_v1_base_proto_enumTypes[2]
}

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

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

type NumberArrayProperties struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// will be removed in the future, use vector_bytes
	// go client 5.4.1 depends on this field. Only remove after go client is deprecated
	//
	// Deprecated: Marked as deprecated in v1/base.proto.
	Values        []float64 `protobuf:"fixed64,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	PropName      string    `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,omitempty"`
	ValuesBytes   []byte    `protobuf:"bytes,3,opt,name=values_bytes,json=valuesBytes,proto3" json:"values_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NumberArrayProperties) ProtoMessage() {}

func (x *NumberArrayProperties) ProtoReflect() protoreflect.Message {
	mi := &file_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 NumberArrayProperties.ProtoReflect.Descriptor instead.
func (*NumberArrayProperties) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{0}
}

// Deprecated: Marked as deprecated in v1/base.proto.
func (x *NumberArrayProperties) GetValues() []float64 {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *NumberArrayProperties) GetPropName() string {
	if x != nil {
		return x.PropName
	}
	return ""
}

func (x *NumberArrayProperties) GetValuesBytes() []byte {
	if x != nil {
		return x.ValuesBytes
	}
	return nil
}

type IntArrayProperties struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []int64                `protobuf:"varint,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	PropName      string                 `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IntArrayProperties) ProtoMessage() {}

func (x *IntArrayProperties) ProtoReflect() protoreflect.Message {
	mi := &file_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 IntArrayProperties.ProtoReflect.Descriptor instead.
func (*IntArrayProperties) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{1}
}

func (x *IntArrayProperties) GetValues() []int64 {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *IntArrayProperties) GetPropName() string {
	if x != nil {
		return x.PropName
	}
	return ""
}

type TextArrayProperties struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []string               `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	PropName      string                 `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TextArrayProperties) ProtoMessage() {}

func (x *TextArrayProperties) ProtoReflect() protoreflect.Message {
	mi := &file_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 TextArrayProperties.ProtoReflect.Descriptor instead.
func (*TextArrayProperties) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{2}
}

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

func (x *TextArrayProperties) GetPropName() string {
	if x != nil {
		return x.PropName
	}
	return ""
}

type BooleanArrayProperties struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []bool                 `protobuf:"varint,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	PropName      string                 `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BooleanArrayProperties) ProtoMessage() {}

func (x *BooleanArrayProperties) ProtoReflect() protoreflect.Message {
	mi := &file_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 BooleanArrayProperties.ProtoReflect.Descriptor instead.
func (*BooleanArrayProperties) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{3}
}

func (x *BooleanArrayProperties) GetValues() []bool {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *BooleanArrayProperties) GetPropName() string {
	if x != nil {
		return x.PropName
	}
	return ""
}

type ObjectPropertiesValue struct {
	state                  protoimpl.MessageState    `protogen:"open.v1"`
	NonRefProperties       *structpb.Struct          `protobuf:"bytes,1,opt,name=non_ref_properties,json=nonRefProperties,proto3" json:"non_ref_properties,omitempty"`
	NumberArrayProperties  []*NumberArrayProperties  `protobuf:"bytes,2,rep,name=number_array_properties,json=numberArrayProperties,proto3" json:"number_array_properties,omitempty"`
	IntArrayProperties     []*IntArrayProperties     `protobuf:"bytes,3,rep,name=int_array_properties,json=intArrayProperties,proto3" json:"int_array_properties,omitempty"`
	TextArrayProperties    []*TextArrayProperties    `protobuf:"bytes,4,rep,name=text_array_properties,json=textArrayProperties,proto3" json:"text_array_properties,omitempty"`
	BooleanArrayProperties []*BooleanArrayProperties `protobuf:"bytes,5,rep,name=boolean_array_properties,json=booleanArrayProperties,proto3" json:"boolean_array_properties,omitempty"`
	ObjectProperties       []*ObjectProperties       `protobuf:"bytes,6,rep,name=object_properties,json=objectProperties,proto3" json:"object_properties,omitempty"`
	ObjectArrayProperties  []*ObjectArrayProperties  `protobuf:"bytes,7,rep,name=object_array_properties,json=objectArrayProperties,proto3" json:"object_array_properties,omitempty"`
	EmptyListProps         []string                  `protobuf:"bytes,10,rep,name=empty_list_props,json=emptyListProps,proto3" json:"empty_list_props,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*ObjectPropertiesValue) ProtoMessage() {}

func (x *ObjectPropertiesValue) ProtoReflect() protoreflect.Message {
	mi := &file_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 ObjectPropertiesValue.ProtoReflect.Descriptor instead.
func (*ObjectPropertiesValue) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{4}
}

func (x *ObjectPropertiesValue) GetNonRefProperties() *structpb.Struct {
	if x != nil {
		return x.NonRefProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetNumberArrayProperties() []*NumberArrayProperties {
	if x != nil {
		return x.NumberArrayProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetIntArrayProperties() []*IntArrayProperties {
	if x != nil {
		return x.IntArrayProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetTextArrayProperties() []*TextArrayProperties {
	if x != nil {
		return x.TextArrayProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetBooleanArrayProperties() []*BooleanArrayProperties {
	if x != nil {
		return x.BooleanArrayProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetObjectProperties() []*ObjectProperties {
	if x != nil {
		return x.ObjectProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetObjectArrayProperties() []*ObjectArrayProperties {
	if x != nil {
		return x.ObjectArrayProperties
	}
	return nil
}

func (x *ObjectPropertiesValue) GetEmptyListProps() []string {
	if x != nil {
		return x.EmptyListProps
	}
	return nil
}

type ObjectArrayProperties struct {
	state         protoimpl.MessageState   `protogen:"open.v1"`
	Values        []*ObjectPropertiesValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	PropName      string                   `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectArrayProperties) ProtoMessage() {}

func (x *ObjectArrayProperties) ProtoReflect() protoreflect.Message {
	mi := &file_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 ObjectArrayProperties.ProtoReflect.Descriptor instead.
func (*ObjectArrayProperties) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{5}
}

func (x *ObjectArrayProperties) GetValues() []*ObjectPropertiesValue {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *ObjectArrayProperties) GetPropName() string {
	if x != nil {
		return x.PropName
	}
	return ""
}

type ObjectProperties struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         *ObjectPropertiesValue `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	PropName      string                 `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectProperties) ProtoMessage() {}

func (x *ObjectProperties) ProtoReflect() protoreflect.Message {
	mi := &file_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 ObjectProperties.ProtoReflect.Descriptor instead.
func (*ObjectProperties) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{6}
}

func (x *ObjectProperties) GetValue() *ObjectPropertiesValue {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *ObjectProperties) GetPropName() string {
	if x != nil {
		return x.PropName
	}
	return ""
}

type TextArray struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []string               `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TextArray) ProtoMessage() {}

func (x *TextArray) ProtoReflect() protoreflect.Message {
	mi := &file_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 TextArray.ProtoReflect.Descriptor instead.
func (*TextArray) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{7}
}

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

type IntArray struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []int64                `protobuf:"varint,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IntArray) ProtoMessage() {}

func (x *IntArray) ProtoReflect() protoreflect.Message {
	mi := &file_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 IntArray.ProtoReflect.Descriptor instead.
func (*IntArray) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{8}
}

func (x *IntArray) GetValues() []int64 {
	if x != nil {
		return x.Values
	}
	return nil
}

type NumberArray struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []float64              `protobuf:"fixed64,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NumberArray) ProtoMessage() {}

func (x *NumberArray) ProtoReflect() protoreflect.Message {
	mi := &file_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 NumberArray.ProtoReflect.Descriptor instead.
func (*NumberArray) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{9}
}

func (x *NumberArray) GetValues() []float64 {
	if x != nil {
		return x.Values
	}
	return nil
}

type BooleanArray struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []bool                 `protobuf:"varint,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BooleanArray) ProtoMessage() {}

func (x *BooleanArray) ProtoReflect() protoreflect.Message {
	mi := &file_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 BooleanArray.ProtoReflect.Descriptor instead.
func (*BooleanArray) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{10}
}

func (x *BooleanArray) GetValues() []bool {
	if x != nil {
		return x.Values
	}
	return nil
}

type Filters struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	Operator Filters_Operator       `protobuf:"varint,1,opt,name=operator,proto3,enum=weaviate.v1.Filters_Operator" json:"operator,omitempty"`
	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
	//
	// Deprecated: Marked as deprecated in v1/base.proto.
	On      []string   `protobuf:"bytes,2,rep,name=on,proto3" json:"on,omitempty"` // will be removed in the future, use path
	Filters []*Filters `protobuf:"bytes,3,rep,name=filters,proto3" json:"filters,omitempty"`
	// Types that are valid to be assigned to TestValue:
	//
	//	*Filters_ValueText
	//	*Filters_ValueInt
	//	*Filters_ValueBoolean
	//	*Filters_ValueNumber
	//	*Filters_ValueTextArray
	//	*Filters_ValueIntArray
	//	*Filters_ValueBooleanArray
	//	*Filters_ValueNumberArray
	//	*Filters_ValueGeo
	TestValue     isFilters_TestValue `protobuf_oneof:"test_value"`
	Target        *FilterTarget       `protobuf:"bytes,20,opt,name=target,proto3" json:"target,omitempty"` // leave space for more filter values
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Filters) ProtoMessage() {}

func (x *Filters) ProtoReflect() protoreflect.Message {
	mi := &file_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 Filters.ProtoReflect.Descriptor instead.
func (*Filters) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{11}
}

func (x *Filters) GetOperator() Filters_Operator {
	if x != nil {
		return x.Operator
	}
	return Filters_OPERATOR_UNSPECIFIED
}

// Deprecated: Marked as deprecated in v1/base.proto.
func (x *Filters) GetOn() []string {
	if x != nil {
		return x.On
	}
	return nil
}

func (x *Filters) GetFilters() []*Filters {
	if x != nil {
		return x.Filters
	}
	return nil
}

func (x *Filters) GetTestValue() isFilters_TestValue {
	if x != nil {
		return x.TestValue
	}
	return nil
}

func (x *Filters) GetValueText() string {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueText); ok {
			return x.ValueText
		}
	}
	return ""
}

func (x *Filters) GetValueInt() int64 {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueInt); ok {
			return x.ValueInt
		}
	}
	return 0
}

func (x *Filters) GetValueBoolean() bool {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueBoolean); ok {
			return x.ValueBoolean
		}
	}
	return false
}

func (x *Filters) GetValueNumber() float64 {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueNumber); ok {
			return x.ValueNumber
		}
	}
	return 0
}

func (x *Filters) GetValueTextArray() *TextArray {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueTextArray); ok {
			return x.ValueTextArray
		}
	}
	return nil
}

func (x *Filters) GetValueIntArray() *IntArray {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueIntArray); ok {
			return x.ValueIntArray
		}
	}
	return nil
}

func (x *Filters) GetValueBooleanArray() *BooleanArray {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueBooleanArray); ok {
			return x.ValueBooleanArray
		}
	}
	return nil
}

func (x *Filters) GetValueNumberArray() *NumberArray {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueNumberArray); ok {
			return x.ValueNumberArray
		}
	}
	return nil
}

func (x *Filters) GetValueGeo() *GeoCoordinatesFilter {
	if x != nil {
		if x, ok := x.TestValue.(*Filters_ValueGeo); ok {
			return x.ValueGeo
		}
	}
	return nil
}

func (x *Filters) GetTarget() *FilterTarget {
	if x != nil {
		return x.Target
	}
	return nil
}

type isFilters_TestValue interface {
	isFilters_TestValue()
}

type Filters_ValueText struct {
	ValueText string `protobuf:"bytes,4,opt,name=value_text,json=valueText,proto3,oneof"`
}

type Filters_ValueInt struct {
	ValueInt int64 `protobuf:"varint,5,opt,name=value_int,json=valueInt,proto3,oneof"`
}

type Filters_ValueBoolean struct {
	ValueBoolean bool `protobuf:"varint,6,opt,name=value_boolean,json=valueBoolean,proto3,oneof"`
}

type Filters_ValueNumber struct {
	ValueNumber float64 `protobuf:"fixed64,7,opt,name=value_number,json=valueNumber,proto3,oneof"`
}

type Filters_ValueTextArray struct {
	ValueTextArray *TextArray `protobuf:"bytes,9,opt,name=value_text_array,json=valueTextArray,proto3,oneof"`
}

type Filters_ValueIntArray struct {
	ValueIntArray *IntArray `protobuf:"bytes,10,opt,name=value_int_array,json=valueIntArray,proto3,oneof"`
}

type Filters_ValueBooleanArray struct {
	ValueBooleanArray *BooleanArray `protobuf:"bytes,11,opt,name=value_boolean_array,json=valueBooleanArray,proto3,oneof"`
}

type Filters_ValueNumberArray struct {
	ValueNumberArray *NumberArray `protobuf:"bytes,12,opt,name=value_number_array,json=valueNumberArray,proto3,oneof"`
}

type Filters_ValueGeo struct {
	ValueGeo *GeoCoordinatesFilter `protobuf:"bytes,13,opt,name=value_geo,json=valueGeo,proto3,oneof"`
}

func (*Filters_ValueText) isFilters_TestValue() {}

func (*Filters_ValueInt) isFilters_TestValue() {}

func (*Filters_ValueBoolean) isFilters_TestValue() {}

func (*Filters_ValueNumber) isFilters_TestValue() {}

func (*Filters_ValueTextArray) isFilters_TestValue() {}

func (*Filters_ValueIntArray) isFilters_TestValue() {}

func (*Filters_ValueBooleanArray) isFilters_TestValue() {}

func (*Filters_ValueNumberArray) isFilters_TestValue() {}

func (*Filters_ValueGeo) isFilters_TestValue() {}

type FilterReferenceSingleTarget struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	On            string                 `protobuf:"bytes,1,opt,name=on,proto3" json:"on,omitempty"`
	Target        *FilterTarget          `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterReferenceSingleTarget) ProtoMessage() {}

func (x *FilterReferenceSingleTarget) ProtoReflect() protoreflect.Message {
	mi := &file_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 FilterReferenceSingleTarget.ProtoReflect.Descriptor instead.
func (*FilterReferenceSingleTarget) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{12}
}

func (x *FilterReferenceSingleTarget) GetOn() string {
	if x != nil {
		return x.On
	}
	return ""
}

func (x *FilterReferenceSingleTarget) GetTarget() *FilterTarget {
	if x != nil {
		return x.Target
	}
	return nil
}

type FilterReferenceMultiTarget struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	On               string                 `protobuf:"bytes,1,opt,name=on,proto3" json:"on,omitempty"`
	Target           *FilterTarget          `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	TargetCollection string                 `protobuf:"bytes,3,opt,name=target_collection,json=targetCollection,proto3" json:"target_collection,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*FilterReferenceMultiTarget) ProtoMessage() {}

func (x *FilterReferenceMultiTarget) ProtoReflect() protoreflect.Message {
	mi := &file_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 FilterReferenceMultiTarget.ProtoReflect.Descriptor instead.
func (*FilterReferenceMultiTarget) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{13}
}

func (x *FilterReferenceMultiTarget) GetOn() string {
	if x != nil {
		return x.On
	}
	return ""
}

func (x *FilterReferenceMultiTarget) GetTarget() *FilterTarget {
	if x != nil {
		return x.Target
	}
	return nil
}

func (x *FilterReferenceMultiTarget) GetTargetCollection() string {
	if x != nil {
		return x.TargetCollection
	}
	return ""
}

type FilterReferenceCount struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	On            string                 `protobuf:"bytes,1,opt,name=on,proto3" json:"on,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterReferenceCount) ProtoMessage() {}

func (x *FilterReferenceCount) ProtoReflect() protoreflect.Message {
	mi := &file_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 FilterReferenceCount.ProtoReflect.Descriptor instead.
func (*FilterReferenceCount) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{14}
}

func (x *FilterReferenceCount) GetOn() string {
	if x != nil {
		return x.On
	}
	return ""
}

type FilterTarget struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Target:
	//
	//	*FilterTarget_Property
	//	*FilterTarget_SingleTarget
	//	*FilterTarget_MultiTarget
	//	*FilterTarget_Count
	Target        isFilterTarget_Target `protobuf_oneof:"target"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterTarget) ProtoMessage() {}

func (x *FilterTarget) ProtoReflect() protoreflect.Message {
	mi := &file_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 FilterTarget.ProtoReflect.Descriptor instead.
func (*FilterTarget) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{15}
}

func (x *FilterTarget) GetTarget() isFilterTarget_Target {
	if x != nil {
		return x.Target
	}
	return nil
}

func (x *FilterTarget) GetProperty() string {
	if x != nil {
		if x, ok := x.Target.(*FilterTarget_Property); ok {
			return x.Property
		}
	}
	return ""
}

func (x *FilterTarget) GetSingleTarget() *FilterReferenceSingleTarget {
	if x != nil {
		if x, ok := x.Target.(*FilterTarget_SingleTarget); ok {
			return x.SingleTarget
		}
	}
	return nil
}

func (x *FilterTarget) GetMultiTarget() *FilterReferenceMultiTarget {
	if x != nil {
		if x, ok := x.Target.(*FilterTarget_MultiTarget); ok {
			return x.MultiTarget
		}
	}
	return nil
}

func (x *FilterTarget) GetCount() *FilterReferenceCount {
	if x != nil {
		if x, ok := x.Target.(*FilterTarget_Count); ok {
			return x.Count
		}
	}
	return nil
}

type isFilterTarget_Target interface {
	isFilterTarget_Target()
}

type FilterTarget_Property struct {
	Property string `protobuf:"bytes,1,opt,name=property,proto3,oneof"`
}

type FilterTarget_SingleTarget struct {
	SingleTarget *FilterReferenceSingleTarget `protobuf:"bytes,2,opt,name=single_target,json=singleTarget,proto3,oneof"`
}

type FilterTarget_MultiTarget struct {
	MultiTarget *FilterReferenceMultiTarget `protobuf:"bytes,3,opt,name=multi_target,json=multiTarget,proto3,oneof"`
}

type FilterTarget_Count struct {
	Count *FilterReferenceCount `protobuf:"bytes,4,opt,name=count,proto3,oneof"`
}

func (*FilterTarget_Property) isFilterTarget_Target() {}

func (*FilterTarget_SingleTarget) isFilterTarget_Target() {}

func (*FilterTarget_MultiTarget) isFilterTarget_Target() {}

func (*FilterTarget_Count) isFilterTarget_Target() {}

type GeoCoordinatesFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Latitude      float32                `protobuf:"fixed32,1,opt,name=latitude,proto3" json:"latitude,omitempty"`
	Longitude     float32                `protobuf:"fixed32,2,opt,name=longitude,proto3" json:"longitude,omitempty"`
	Distance      float32                `protobuf:"fixed32,3,opt,name=distance,proto3" json:"distance,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GeoCoordinatesFilter) ProtoMessage() {}

func (x *GeoCoordinatesFilter) ProtoReflect() protoreflect.Message {
	mi := &file_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 GeoCoordinatesFilter.ProtoReflect.Descriptor instead.
func (*GeoCoordinatesFilter) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{16}
}

func (x *GeoCoordinatesFilter) GetLatitude() float32 {
	if x != nil {
		return x.Latitude
	}
	return 0
}

func (x *GeoCoordinatesFilter) GetLongitude() float32 {
	if x != nil {
		return x.Longitude
	}
	return 0
}

func (x *GeoCoordinatesFilter) GetDistance() float32 {
	if x != nil {
		return x.Distance
	}
	return 0
}

type Vectors struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Name  string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Deprecated: Marked as deprecated in v1/base.proto.
	Index         uint64             `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` // for multi-vec
	VectorBytes   []byte             `protobuf:"bytes,3,opt,name=vector_bytes,json=vectorBytes,proto3" json:"vector_bytes,omitempty"`
	Type          Vectors_VectorType `protobuf:"varint,4,opt,name=type,proto3,enum=weaviate.v1.Vectors_VectorType" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Vectors) ProtoMessage() {}

func (x *Vectors) ProtoReflect() protoreflect.Message {
	mi := &file_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 Vectors.ProtoReflect.Descriptor instead.
func (*Vectors) Descriptor() ([]byte, []int) {
	return file_v1_base_proto_rawDescGZIP(), []int{17}
}

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

// Deprecated: Marked as deprecated in v1/base.proto.
func (x *Vectors) GetIndex() uint64 {
	if x != nil {
		return x.Index
	}
	return 0
}

func (x *Vectors) GetVectorBytes() []byte {
	if x != nil {
		return x.VectorBytes
	}
	return nil
}

func (x *Vectors) GetType() Vectors_VectorType {
	if x != nil {
		return x.Type
	}
	return Vectors_VECTOR_TYPE_UNSPECIFIED
}

var File_v1_base_proto protoreflect.FileDescriptor

const file_v1_base_proto_rawDesc = "" +
	"\n" +
	"\rv1/base.proto\x12\vweaviate.v1\x1a\x1cgoogle/protobuf/struct.proto\"s\n" +
	"\x15NumberArrayProperties\x12\x1a\n" +
	"\x06values\x18\x01 \x03(\x01B\x02\x18\x01R\x06values\x12\x1b\n" +
	"\tprop_name\x18\x02 \x01(\tR\bpropName\x12!\n" +
	"\fvalues_bytes\x18\x03 \x01(\fR\vvaluesBytes\"I\n" +
	"\x12IntArrayProperties\x12\x16\n" +
	"\x06values\x18\x01 \x03(\x03R\x06values\x12\x1b\n" +
	"\tprop_name\x18\x02 \x01(\tR\bpropName\"J\n" +
	"\x13TextArrayProperties\x12\x16\n" +
	"\x06values\x18\x01 \x03(\tR\x06values\x12\x1b\n" +
	"\tprop_name\x18\x02 \x01(\tR\bpropName\"M\n" +
	"\x16BooleanArrayProperties\x12\x16\n" +
	"\x06values\x18\x01 \x03(\bR\x06values\x12\x1b\n" +
	"\tprop_name\x18\x02 \x01(\tR\bpropName\"\x94\x05\n" +
	"\x15ObjectPropertiesValue\x12E\n" +
	"\x12non_ref_properties\x18\x01 \x01(\v2\x17.google.protobuf.StructR\x10nonRefProperties\x12Z\n" +
	"\x17number_array_properties\x18\x02 \x03(\v2\".weaviate.v1.NumberArrayPropertiesR\x15numberArrayProperties\x12Q\n" +
	"\x14int_array_properties\x18\x03 \x03(\v2\x1f.weaviate.v1.IntArrayPropertiesR\x12intArrayProperties\x12T\n" +
	"\x15text_array_properties\x18\x04 \x03(\v2 .weaviate.v1.TextArrayPropertiesR\x13textArrayProperties\x12]\n" +
	"\x18boolean_array_properties\x18\x05 \x03(\v2#.weaviate.v1.BooleanArrayPropertiesR\x16booleanArrayProperties\x12J\n" +
	"\x11object_properties\x18\x06 \x03(\v2\x1d.weaviate.v1.ObjectPropertiesR\x10objectProperties\x12Z\n" +
	"\x17object_array_properties\x18\a \x03(\v2\".weaviate.v1.ObjectArrayPropertiesR\x15objectArrayProperties\x12(\n" +
	"\x10empty_list_props\x18\n" +
	" \x03(\tR\x0eemptyListProps\"p\n" +
	"\x15ObjectArrayProperties\x12:\n" +
	"\x06values\x18\x01 \x03(\v2\".weaviate.v1.ObjectPropertiesValueR\x06values\x12\x1b\n" +
	"\tprop_name\x18\x02 \x01(\tR\bpropName\"i\n" +
	"\x10ObjectProperties\x128\n" +
	"\x05value\x18\x01 \x01(\v2\".weaviate.v1.ObjectPropertiesValueR\x05value\x12\x1b\n" +
	"\tprop_name\x18\x02 \x01(\tR\bpropName\"#\n" +
	"\tTextArray\x12\x16\n" +
	"\x06values\x18\x01 \x03(\tR\x06values\"\"\n" +
	"\bIntArray\x12\x16\n" +
	"\x06values\x18\x01 \x03(\x03R\x06values\"%\n" +
	"\vNumberArray\x12\x16\n" +
	"\x06values\x18\x01 \x03(\x01R\x06values\"&\n" +
	"\fBooleanArray\x12\x16\n" +
	"\x06values\x18\x01 \x03(\bR\x06values\"\xc7\b\n" +
	"\aFilters\x129\n" +
	"\boperator\x18\x01 \x01(\x0e2\x1d.weaviate.v1.Filters.OperatorR\boperator\x12\x12\n" +
	"\x02on\x18\x02 \x03(\tB\x02\x18\x01R\x02on\x12.\n" +
	"\afilters\x18\x03 \x03(\v2\x14.weaviate.v1.FiltersR\afilters\x12\x1f\n" +
	"\n" +
	"value_text\x18\x04 \x01(\tH\x00R\tvalueText\x12\x1d\n" +
	"\tvalue_int\x18\x05 \x01(\x03H\x00R\bvalueInt\x12%\n" +
	"\rvalue_boolean\x18\x06 \x01(\bH\x00R\fvalueBoolean\x12#\n" +
	"\fvalue_number\x18\a \x01(\x01H\x00R\vvalueNumber\x12B\n" +
	"\x10value_text_array\x18\t \x01(\v2\x16.weaviate.v1.TextArrayH\x00R\x0evalueTextArray\x12?\n" +
	"\x0fvalue_int_array\x18\n" +
	" \x01(\v2\x15.weaviate.v1.IntArrayH\x00R\rvalueIntArray\x12K\n" +
	"\x13value_boolean_array\x18\v \x01(\v2\x19.weaviate.v1.BooleanArrayH\x00R\x11valueBooleanArray\x12H\n" +
	"\x12value_number_array\x18\f \x01(\v2\x18.weaviate.v1.NumberArrayH\x00R\x10valueNumberArray\x12@\n" +
	"\tvalue_geo\x18\r \x01(\v2!.weaviate.v1.GeoCoordinatesFilterH\x00R\bvalueGeo\x121\n" +
	"\x06target\x18\x14 \x01(\v2\x19.weaviate.v1.FilterTargetR\x06target\"\x91\x03\n" +
	"\bOperator\x12\x18\n" +
	"\x14OPERATOR_UNSPECIFIED\x10\x00\x12\x12\n" +
	"\x0eOPERATOR_EQUAL\x10\x01\x12\x16\n" +
	"\x12OPERATOR_NOT_EQUAL\x10\x02\x12\x19\n" +
	"\x15OPERATOR_GREATER_THAN\x10\x03\x12\x1f\n" +
	"\x1bOPERATOR_GREATER_THAN_EQUAL\x10\x04\x12\x16\n" +
	"\x12OPERATOR_LESS_THAN\x10\x05\x12\x1c\n" +
	"\x18OPERATOR_LESS_THAN_EQUAL\x10\x06\x12\x10\n" +
	"\fOPERATOR_AND\x10\a\x12\x0f\n" +
	"\vOPERATOR_OR\x10\b\x12\x1d\n" +
	"\x19OPERATOR_WITHIN_GEO_RANGE\x10\t\x12\x11\n" +
	"\rOPERATOR_LIKE\x10\n" +
	"\x12\x14\n" +
	"\x10OPERATOR_IS_NULL\x10\v\x12\x19\n" +
	"\x15OPERATOR_CONTAINS_ANY\x10\f\x12\x19\n" +
	"\x15OPERATOR_CONTAINS_ALL\x10\r\x12\x1a\n" +
	"\x16OPERATOR_CONTAINS_NONE\x10\x0e\x12\x10\n" +
	"\fOPERATOR_NOT\x10\x0fB\f\n" +
	"\n" +
	"test_value\"`\n" +
	"\x1bFilterReferenceSingleTarget\x12\x0e\n" +
	"\x02on\x18\x01 \x01(\tR\x02on\x121\n" +
	"\x06target\x18\x02 \x01(\v2\x19.weaviate.v1.FilterTargetR\x06target\"\x8c\x01\n" +
	"\x1aFilterReferenceMultiTarget\x12\x0e\n" +
	"\x02on\x18\x01 \x01(\tR\x02on\x121\n" +
	"\x06target\x18\x02 \x01(\v2\x19.weaviate.v1.FilterTargetR\x06target\x12+\n" +
	"\x11target_collection\x18\x03 \x01(\tR\x10targetCollection\"&\n" +
	"\x14FilterReferenceCount\x12\x0e\n" +
	"\x02on\x18\x01 \x01(\tR\x02on\"\x90\x02\n" +
	"\fFilterTarget\x12\x1c\n" +
	"\bproperty\x18\x01 \x01(\tH\x00R\bproperty\x12O\n" +
	"\rsingle_target\x18\x02 \x01(\v2(.weaviate.v1.FilterReferenceSingleTargetH\x00R\fsingleTarget\x12L\n" +
	"\fmulti_target\x18\x03 \x01(\v2'.weaviate.v1.FilterReferenceMultiTargetH\x00R\vmultiTarget\x129\n" +
	"\x05count\x18\x04 \x01(\v2!.weaviate.v1.FilterReferenceCountH\x00R\x05countB\b\n" +
	"\x06target\"l\n" +
	"\x14GeoCoordinatesFilter\x12\x1a\n" +
	"\blatitude\x18\x01 \x01(\x02R\blatitude\x12\x1c\n" +
	"\tlongitude\x18\x02 \x01(\x02R\tlongitude\x12\x1a\n" +
	"\bdistance\x18\x03 \x01(\x02R\bdistance\"\xf3\x01\n" +
	"\aVectors\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
	"\x05index\x18\x02 \x01(\x04B\x02\x18\x01R\x05index\x12!\n" +
	"\fvector_bytes\x18\x03 \x01(\fR\vvectorBytes\x123\n" +
	"\x04type\x18\x04 \x01(\x0e2\x1f.weaviate.v1.Vectors.VectorTypeR\x04type\"b\n" +
	"\n" +
	"VectorType\x12\x1b\n" +
	"\x17VECTOR_TYPE_UNSPECIFIED\x10\x00\x12\x1b\n" +
	"\x17VECTOR_TYPE_SINGLE_FP32\x10\x01\x12\x1a\n" +
	"\x16VECTOR_TYPE_MULTI_FP32\x10\x02*\x89\x01\n" +
	"\x10ConsistencyLevel\x12!\n" +
	"\x1dCONSISTENCY_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n" +
	"\x15CONSISTENCY_LEVEL_ONE\x10\x01\x12\x1c\n" +
	"\x18CONSISTENCY_LEVEL_QUORUM\x10\x02\x12\x19\n" +
	"\x15CONSISTENCY_LEVEL_ALL\x10\x03Bn\n" +
	"#io.weaviate.client.grpc.protocol.v1B\x11WeaviateProtoBaseZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"

var (
	file_v1_base_proto_rawDescOnce sync.Once
	file_v1_base_proto_rawDescData []byte
)

func file_v1_base_proto_rawDescGZIP() []byte {
	file_v1_base_proto_rawDescOnce.Do(func() {
		file_v1_base_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_base_proto_rawDesc), len(file_v1_base_proto_rawDesc)))
	})
	return file_v1_base_proto_rawDescData
}

var file_v1_base_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_v1_base_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
var file_v1_base_proto_goTypes = []any{
	(ConsistencyLevel)(0),               // 0: weaviate.v1.ConsistencyLevel
	(Filters_Operator)(0),               // 1: weaviate.v1.Filters.Operator
	(Vectors_VectorType)(0),             // 2: weaviate.v1.Vectors.VectorType
	(*NumberArrayProperties)(nil),       // 3: weaviate.v1.NumberArrayProperties
	(*IntArrayProperties)(nil),          // 4: weaviate.v1.IntArrayProperties
	(*TextArrayProperties)(nil),         // 5: weaviate.v1.TextArrayProperties
	(*BooleanArrayProperties)(nil),      // 6: weaviate.v1.BooleanArrayProperties
	(*ObjectPropertiesValue)(nil),       // 7: weaviate.v1.ObjectPropertiesValue
	(*ObjectArrayProperties)(nil),       // 8: weaviate.v1.ObjectArrayProperties
	(*ObjectProperties)(nil),            // 9: weaviate.v1.ObjectProperties
	(*TextArray)(nil),                   // 10: weaviate.v1.TextArray
	(*IntArray)(nil),                    // 11: weaviate.v1.IntArray
	(*NumberArray)(nil),                 // 12: weaviate.v1.NumberArray
	(*BooleanArray)(nil),                // 13: weaviate.v1.BooleanArray
	(*Filters)(nil),                     // 14: weaviate.v1.Filters
	(*FilterReferenceSingleTarget)(nil), // 15: weaviate.v1.FilterReferenceSingleTarget
	(*FilterReferenceMultiTarget)(nil),  // 16: weaviate.v1.FilterReferenceMultiTarget
	(*FilterReferenceCount)(nil),        // 17: weaviate.v1.FilterReferenceCount
	(*FilterTarget)(nil),                // 18: weaviate.v1.FilterTarget
	(*GeoCoordinatesFilter)(nil),        // 19: weaviate.v1.GeoCoordinatesFilter
	(*Vectors)(nil),                     // 20: weaviate.v1.Vectors
	(*structpb.Struct)(nil),             // 21: google.protobuf.Struct
}
var file_v1_base_proto_depIdxs = []int32{
	21, // 0: weaviate.v1.ObjectPropertiesValue.non_ref_properties:type_name -> google.protobuf.Struct
	3,  // 1: weaviate.v1.ObjectPropertiesValue.number_array_properties:type_name -> weaviate.v1.NumberArrayProperties
	4,  // 2: weaviate.v1.ObjectPropertiesValue.int_array_properties:type_name -> weaviate.v1.IntArrayProperties
	5,  // 3: weaviate.v1.ObjectPropertiesValue.text_array_properties:type_name -> weaviate.v1.TextArrayProperties
	6,  // 4: weaviate.v1.ObjectPropertiesValue.boolean_array_properties:type_name -> weaviate.v1.BooleanArrayProperties
	9,  // 5: weaviate.v1.ObjectPropertiesValue.object_properties:type_name -> weaviate.v1.ObjectProperties
	8,  // 6: weaviate.v1.ObjectPropertiesValue.object_array_properties:type_name -> weaviate.v1.ObjectArrayProperties
	7,  // 7: weaviate.v1.ObjectArrayProperties.values:type_name -> weaviate.v1.ObjectPropertiesValue
	7,  // 8: weaviate.v1.ObjectProperties.value:type_name -> weaviate.v1.ObjectPropertiesValue
	1,  // 9: weaviate.v1.Filters.operator:type_name -> weaviate.v1.Filters.Operator
	14, // 10: weaviate.v1.Filters.filters:type_name -> weaviate.v1.Filters
	10, // 11: weaviate.v1.Filters.value_text_array:type_name -> weaviate.v1.TextArray
	11, // 12: weaviate.v1.Filters.value_int_array:type_name -> weaviate.v1.IntArray
	13, // 13: weaviate.v1.Filters.value_boolean_array:type_name -> weaviate.v1.BooleanArray
	12, // 14: weaviate.v1.Filters.value_number_array:type_name -> weaviate.v1.NumberArray
	19, // 15: weaviate.v1.Filters.value_geo:type_name -> weaviate.v1.GeoCoordinatesFilter
	18, // 16: weaviate.v1.Filters.target:type_name -> weaviate.v1.FilterTarget
	18, // 17: weaviate.v1.FilterReferenceSingleTarget.target:type_name -> weaviate.v1.FilterTarget
	18, // 18: weaviate.v1.FilterReferenceMultiTarget.target:type_name -> weaviate.v1.FilterTarget
	15, // 19: weaviate.v1.FilterTarget.single_target:type_name -> weaviate.v1.FilterReferenceSingleTarget
	16, // 20: weaviate.v1.FilterTarget.multi_target:type_name -> weaviate.v1.FilterReferenceMultiTarget
	17, // 21: weaviate.v1.FilterTarget.count:type_name -> weaviate.v1.FilterReferenceCount
	2,  // 22: weaviate.v1.Vectors.type:type_name -> weaviate.v1.Vectors.VectorType
	23, // [23:23] is the sub-list for method output_type
	23, // [23:23] is the sub-list for method input_type
	23, // [23:23] is the sub-list for extension type_name
	23, // [23:23] is the sub-list for extension extendee
	0,  // [0:23] is the sub-list for field type_name
}

func init() { file_v1_base_proto_init() }
func file_v1_base_proto_init() {
	if File_v1_base_proto != nil {
		return
	}
	file_v1_base_proto_msgTypes[11].OneofWrappers = []any{
		(*Filters_ValueText)(nil),
		(*Filters_ValueInt)(nil),
		(*Filters_ValueBoolean)(nil),
		(*Filters_ValueNumber)(nil),
		(*Filters_ValueTextArray)(nil),
		(*Filters_ValueIntArray)(nil),
		(*Filters_ValueBooleanArray)(nil),
		(*Filters_ValueNumberArray)(nil),
		(*Filters_ValueGeo)(nil),
	}
	file_v1_base_proto_msgTypes[15].OneofWrappers = []any{
		(*FilterTarget_Property)(nil),
		(*FilterTarget_SingleTarget)(nil),
		(*FilterTarget_MultiTarget)(nil),
		(*FilterTarget_Count)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_base_proto_rawDesc), len(file_v1_base_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   18,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_v1_base_proto_goTypes,
		DependencyIndexes: file_v1_base_proto_depIdxs,
		EnumInfos:         file_v1_base_proto_enumTypes,
		MessageInfos:      file_v1_base_proto_msgTypes,
	}.Build()
	File_v1_base_proto = out.File
	file_v1_base_proto_goTypes = nil
	file_v1_base_proto_depIdxs = nil
}
