Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/entities/schema/config/vector_index_config.go

@@ -0,0 +1,70 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package config
+
+import (
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modelsext"
+)
+
+type VectorIndexConfig interface {
+	IndexType() string
+	DistanceName() string
+	IsMultiVector() bool
+}
+
+func TypeAssertVectorIndex(class *models.Class, targetVectors []string) ([]VectorIndexConfig, error) {
+	if len(class.VectorConfig) == 0 || (modelsext.ClassHasLegacyVectorIndex(class) && len(targetVectors) == 0) {
+		vectorIndexConfig, ok := class.VectorIndexConfig.(VectorIndexConfig)
+		if !ok {
+			return nil, fmt.Errorf("class '%s' vector index: config is not schema.VectorIndexConfig: %T",
+				class.Class, class.VectorIndexConfig)
+		}
+		return []VectorIndexConfig{vectorIndexConfig}, nil
+	}
+
+	if len(class.VectorConfig) == 1 {
+		var vectorConfig models.VectorConfig
+		for _, v := range class.VectorConfig {
+			vectorConfig = v
+			break
+		}
+		vectorIndexConfig, ok := vectorConfig.VectorIndexConfig.(VectorIndexConfig)
+		if !ok {
+			return nil, fmt.Errorf("class '%s' vector index: config is not schema.VectorIndexConfig: %T",
+				class.Class, class.VectorIndexConfig)
+		}
+		return []VectorIndexConfig{vectorIndexConfig}, nil
+	}
+
+	if len(targetVectors) == 0 {
+		return nil, errors.Errorf("multiple vector configs found for class '%s', but no target vector specified", class.Class)
+	}
+
+	configs := make([]VectorIndexConfig, 0, len(targetVectors))
+	for _, targetVector := range targetVectors {
+		vectorConfig, ok := modelsext.ClassGetVectorConfig(class, targetVector)
+		if !ok {
+			return nil, errors.Errorf("vector config not found for target vector: %s", targetVector)
+		}
+		vectorIndexConfig, ok := vectorConfig.VectorIndexConfig.(VectorIndexConfig)
+		if !ok {
+			return nil, fmt.Errorf("targetVector '%s' vector index: config is not schema.VectorIndexConfig: %T",
+				targetVector, class.VectorIndexConfig)
+		}
+		configs = append(configs, vectorIndexConfig)
+	}
+	return configs, nil
+}

platform/dbops/binaries/weaviate-src/entities/schema/configvalidation/config_validation.go

@@ -0,0 +1,44 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package configvalidation
+
+import (
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+func CheckCertaintyCompatibility(class *models.Class, targetVectors []string) error {
+	if class == nil {
+		return errors.Errorf("no class provided to check certainty compatibility")
+	}
+	if len(targetVectors) > 1 {
+		return errors.Errorf("multiple target vectors are not supported with certainty")
+	}
+
+	vectorConfigs, err := config.TypeAssertVectorIndex(class, targetVectors)
+	if err != nil {
+		return err
+	}
+	if dn := vectorConfigs[0].DistanceName(); dn != common.DistanceCosine {
+		return certaintyUnsupportedError(dn)
+	}
+
+	return nil
+}
+
+func certaintyUnsupportedError(distType string) error {
+	return errors.Errorf(
+		"can't compute and return certainty when vector index is configured with %s distance",
+		distType)
+}

platform/dbops/binaries/weaviate-src/entities/schema/configvalidation/config_validation_test.go

@@ -0,0 +1,61 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package configvalidation
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	vectorIndex "github.com/weaviate/weaviate/entities/vectorindex/common"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+)
+
+func TestCertainty(t *testing.T) {
+	cases := []struct {
+		name          string
+		targetVectors []string
+		class         *models.Class
+		fail          bool
+	}{
+		{name: "no vectorizer", targetVectors: nil, class: &models.Class{}, fail: true},
+		{name: "cosine", targetVectors: nil, class: &models.Class{VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}}, fail: false},
+		{name: "dot", targetVectors: nil, class: &models.Class{VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceDot}}, fail: true},
+		{name: "single target vector", targetVectors: []string{"named"}, class: &models.Class{VectorConfig: map[string]models.VectorConfig{
+			"named":  {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}},
+			"named2": {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}},
+		}}, fail: false},
+		{name: "multi target vector", targetVectors: []string{"named", "named2"}, class: &models.Class{VectorConfig: map[string]models.VectorConfig{
+			"named":  {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}},
+			"named2": {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}},
+		}}, fail: true},
+		{name: "single target vector and dot", targetVectors: []string{"named"}, class: &models.Class{VectorConfig: map[string]models.VectorConfig{
+			"named":  {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceDot}},
+			"named2": {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}},
+		}}, fail: true},
+		{name: "single target vector and dot for non selected", targetVectors: []string{"named2"}, class: &models.Class{VectorConfig: map[string]models.VectorConfig{
+			"named":  {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceDot}},
+			"named2": {VectorIndexConfig: hnsw.UserConfig{Distance: vectorIndex.DistanceCosine}},
+		}}, fail: false},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			err := CheckCertaintyCompatibility(tt.class, tt.targetVectors)
+			if tt.fail {
+				require.NotNil(t, err)
+			} else {
+				require.Nil(t, err)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/entities/schema/crossref/bulk_builder.go

@@ -0,0 +1,107 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package crossref
+
+import (
+	"fmt"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/usecases/byteops"
+)
+
+// BulkBuilder is a low-alloc tool to build many beacon strings (as []byte). It
+// is optimized to allocate just once as opposed to once per ID. This makes it
+// considerably faster when generating 100s of thousand of beacons strings. The
+// main intended use case for this is building propValuePairs in ref-filters.
+//
+// The BulkBuilder makes some estimations for how much memory will be necessary
+// based on expected input params. If those requirements get exceeded, it will
+// still be safe to use, but will fallback to allocating dynamically.
+type BulkBuilder struct {
+	byteops.ReadWriter
+	prefix []byte
+}
+
+func NewBulkBuilderWithEstimates(expectedCount int, exampleClassName string,
+	overheadRatio float64,
+) *BulkBuilder {
+	prefix := []byte("weaviate://localhost/")
+
+	lenOfTypicalClassName := int(float64(len(exampleClassName)) * overheadRatio)
+	predictedSize := expectedCount * (len(prefix) + 1 + lenOfTypicalClassName + 36)
+
+	bb := &BulkBuilder{
+		prefix:     prefix,
+		ReadWriter: byteops.NewReadWriter(make([]byte, predictedSize)),
+	}
+
+	return bb
+}
+
+func (bb *BulkBuilder) ClassAndID(className string,
+	id strfmt.UUID,
+) []byte {
+	requiredSpace := len(bb.prefix) + len(id)
+	if int(bb.Position)+requiredSpace >= len(bb.Buffer) {
+		return bb.fallbackWithClassName(className, id)
+	}
+
+	// copy the start pos, we will need this at the end to know what to return to
+	// the caller
+	start := bb.Position
+	bb.CopyBytesToBuffer(bb.prefix)
+
+	// This is a safe way, in case a class-name ever contains non-ASCII
+	// characters. If we could be 100% sure that a class is ASCII-only, we could
+	// remove this allocation and instead use the same copy-by-rune approach that
+	// we use later on for the ID.
+	bb.CopyBytesToBuffer([]byte(className))
+	bb.WriteByte('/') // The separating slash between class and ID
+	for _, runeValue := range id {
+		// We know that the UUID-string never contains non-ASCII characters. This
+		// means it safe to convert the uint32-rune into a uint8. This allows us to
+		// copy char by char without any additional allocs
+		bb.WriteByte(uint8(runeValue))
+	}
+
+	return bb.Buffer[start:bb.Position]
+}
+
+func (bb *BulkBuilder) LegacyIDOnly(id strfmt.UUID) []byte {
+	requiredSpace := len(bb.prefix) + len(id)
+	if int(bb.Position)+requiredSpace >= len(bb.Buffer) {
+		return bb.fallbackWithoutClassName(id)
+	}
+
+	// copy the start pos, we will need this at the end to know what to return to
+	// the caller
+	start := bb.Position
+	bb.CopyBytesToBuffer(bb.prefix)
+	for _, runeValue := range id {
+		// We know that the UUID-string never contains non-ASCII characters. This
+		// means it safe to convert the uint32-rune into a uint8. This allows us to
+		// copy char by char without any additional allocs
+		bb.WriteByte(uint8(runeValue))
+	}
+
+	return bb.Buffer[start:bb.Position]
+}
+
+func (bb *BulkBuilder) fallbackWithClassName(
+	className string, id strfmt.UUID,
+) []byte {
+	return []byte(fmt.Sprintf("%s%s/%s", bb.prefix, className, id))
+}
+
+func (bb *BulkBuilder) fallbackWithoutClassName(id strfmt.UUID) []byte {
+	return []byte(fmt.Sprintf("%s%s", bb.prefix, id))
+}

platform/dbops/binaries/weaviate-src/entities/schema/crossref/bulk_builder_test.go

@@ -0,0 +1,109 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package crossref
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBulkBuilder(t *testing.T) {
+	tests := []struct {
+		name          string
+		expectedFn    func(id string) string
+		estimatedSize int
+		iterations    int
+		className     string
+		withClassName bool
+	}{
+		{
+			name:          "with class name - enough-prealloc",
+			withClassName: true,
+			className:     "MyClass",
+			expectedFn: func(id string) string {
+				return fmt.Sprintf("weaviate://localhost/MyClass/%s", id)
+			},
+			estimatedSize: 25,
+			iterations:    25,
+		},
+		{
+			name:          "with class name with non-ASCII- enough-prealloc",
+			withClassName: true,
+			className:     "My國Class",
+			expectedFn: func(id string) string {
+				return fmt.Sprintf("weaviate://localhost/My國Class/%s", id)
+			},
+			estimatedSize: 25,
+			iterations:    25,
+		},
+		{
+			name:          "with class name - not enough-prealloc",
+			withClassName: true,
+			className:     "MyClass",
+			expectedFn: func(id string) string {
+				return fmt.Sprintf("weaviate://localhost/MyClass/%s", id)
+			},
+			estimatedSize: 10,
+			iterations:    25,
+		},
+		{
+			name:          "with class name with non-ASCII - not enough-prealloc",
+			withClassName: true,
+			className:     "My國Class",
+			expectedFn: func(id string) string {
+				return fmt.Sprintf("weaviate://localhost/My國Class/%s", id)
+			},
+			estimatedSize: 10,
+			iterations:    25,
+		},
+		{
+			name:          "without class name - enough-prealloc",
+			withClassName: false,
+			className:     "MyClass",
+			expectedFn: func(id string) string {
+				return fmt.Sprintf("weaviate://localhost/%s", id)
+			},
+			estimatedSize: 25,
+			iterations:    25,
+		},
+		{
+			name:          "without class name - not enough-prealloc",
+			withClassName: false,
+			className:     "MyClass",
+			expectedFn: func(id string) string {
+				return fmt.Sprintf("weaviate://localhost/%s", id)
+			},
+			estimatedSize: 10,
+			iterations:    25,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			bb := NewBulkBuilderWithEstimates(tt.estimatedSize, tt.className, 1.00)
+			for i := 0; i < tt.iterations; i++ {
+				id := uuid.New().String()
+				if tt.withClassName {
+					res := bb.ClassAndID(tt.className, strfmt.UUID(id))
+					assert.Equal(t, tt.expectedFn(id), string(res))
+				} else {
+					res := bb.LegacyIDOnly(strfmt.UUID(id))
+					assert.Equal(t, tt.expectedFn(id), string(res))
+				}
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/entities/schema/crossref/crossref.go

@@ -0,0 +1,117 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package crossref
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+const (
+	_LocalHost = "localhost"
+	_Schema    = "weaviate"
+)
+
+// Ref is an abstraction of the cross-refs which are specified in a URI format
+// in the API. When this type is used it is safe to assume that a Ref is
+// semantically valid. This guarantee would not be possible on the URI format,
+// as the URI can be well-formed, but not contain the data we expect in it.
+// Do not use directly, such as crossref.Ref{}, as you won't have any
+// guarantees in this case. Always use one of the parsing options or New()
+type Ref struct {
+	Local    bool        `json:"local"`
+	PeerName string      `json:"peerName"`
+	TargetID strfmt.UUID `json:"targetID"`
+	Class    string      `json:"className"`
+}
+
+// Parse is a safe way to generate a Ref, as it will error if any of the input
+// parameters are not as expected.
+func Parse(uriString string) (*Ref, error) {
+	uri, err := url.Parse(uriString)
+	if err != nil || uri.Path == "" {
+		return nil, fmt.Errorf("invalid cref URI: %w", err)
+	}
+
+	segments := strings.Split(uri.Path, "/")
+	class, id, idx := "", "", 1
+	switch len(segments) {
+	case 3:
+		class = segments[1]
+		id = segments[2]
+		idx = 2
+	case 2:
+		id = segments[1]
+	default:
+		return nil, fmt.Errorf(
+			"invalid cref URI: path must be of format '<class>/<uuid>', but got '%s'", uri.Path)
+	}
+	if ok := strfmt.IsUUID(id); !ok {
+		return nil, fmt.Errorf("invalid cref URI: %dnd path segment must be uuid, but got '%s'",
+			idx, id)
+	}
+
+	return &Ref{
+		Local:    uri.Host == _LocalHost,
+		PeerName: uri.Host,
+		TargetID: strfmt.UUID(id),
+		Class:    class,
+	}, nil
+}
+
+// ParseSingleRef is a safe way to generate a Ref from a models.SingleRef, a
+// helper construct that represents the API structure. It will error if any of
+// the input parameters are not as expected.
+func ParseSingleRef(singleRef *models.SingleRef) (*Ref, error) {
+	return Parse(string(singleRef.Beacon))
+}
+
+// New is a safe way to generate a Reference, as all required arguments must be
+// set in the constructor fn
+func New(peerName string, class string, target strfmt.UUID) *Ref {
+	return &Ref{
+		Local:    peerName == _LocalHost,
+		PeerName: peerName,
+		TargetID: target,
+		Class:    class,
+	}
+}
+
+func NewLocalhost(class string, target strfmt.UUID) *Ref {
+	return New(_LocalHost, class, target)
+}
+
+func (r *Ref) String() string {
+	path := fmt.Sprintf("%s/%s", r.Class, r.TargetID)
+	if r.Class == "" {
+		path = fmt.Sprintf("/%s", r.TargetID)
+	}
+	uri := url.URL{
+		Host:   r.PeerName,
+		Scheme: _Schema,
+		Path:   path,
+	}
+
+	return uri.String()
+}
+
+// SingleRef converts the parsed Ref back into the API helper construct
+// containing a stringified representation (URI format) of the Ref
+func (r *Ref) SingleRef() *models.SingleRef {
+	return &models.SingleRef{
+		Beacon: strfmt.URI(r.String()),
+	}
+}

platform/dbops/binaries/weaviate-src/entities/schema/crossref/crossref_source.go

@@ -0,0 +1,102 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package crossref
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+	"unicode"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+// RefSource is an abstraction of the source of a cross-ref. The opposite would
+// be Ref which represents the target instead. A RefSource is specified in a URI
+// format in the API. When this type is used it is safe to assume that a Ref is
+// semantically valid. This guarantee would not be possible on the URI format,
+// as the URI can be well-formed, but not contain the data we expect in it.  Do
+// not use directly, such as crossref.RefSource{}, as you won't have any
+// guarantees in this case. Always use one of the parsing options or New()
+type RefSource struct {
+	Local    bool                `json:"local"`
+	PeerName string              `json:"peerName"`
+	Property schema.PropertyName `json:"property"`
+	Class    schema.ClassName    `json:"class"`
+	TargetID strfmt.UUID         `json:"targetID"`
+}
+
+func NewSource(className schema.ClassName,
+	property schema.PropertyName, id strfmt.UUID,
+) *RefSource {
+	return &RefSource{
+		Local:    true,
+		PeerName: "localhost",
+		Class:    className,
+		TargetID: id,
+		Property: property,
+	}
+}
+
+// ParseSource is a safe way to generate a RefSource, as it will error if any
+// of the input parameters are not as expected.
+func ParseSource(uriString string) (*RefSource, error) {
+	uri, err := url.Parse(uriString)
+	if err != nil {
+		return nil, fmt.Errorf("invalid cref URI: %w", err)
+	}
+
+	pathSegments := strings.Split(uri.Path, "/")
+	if len(pathSegments) != 4 {
+		return nil, fmt.Errorf(
+			"invalid cref URI: must use long-form: path must be of format '/<className>/<uuid>/<propertyName>', but got '%s'",
+			uri.Path)
+	}
+
+	if ok := strfmt.IsUUID(pathSegments[2]); !ok {
+		return nil, fmt.Errorf("invalid cref URI: 2nd path segment must be uuid, but got '%s'",
+			pathSegments[3])
+	}
+
+	class := pathSegments[1]
+	if class == "" {
+		return nil, fmt.Errorf("className cannot be empty")
+	}
+
+	if unicode.IsLower(rune(class[0])) {
+		return nil, fmt.Errorf("className must start with an uppercase letter, but got %s", class)
+	}
+
+	property := pathSegments[3]
+	if property == "" {
+		return nil, fmt.Errorf("property cannot be empty")
+	}
+
+	return &RefSource{
+		Local:    (uri.Host == "localhost"),
+		PeerName: uri.Host,
+		TargetID: strfmt.UUID(pathSegments[2]),
+		Class:    schema.ClassName(class),
+		Property: schema.PropertyName(property),
+	}, nil
+}
+
+func (r *RefSource) String() string {
+	uri := url.URL{
+		Host:   r.PeerName,
+		Scheme: "weaviate",
+		Path:   fmt.Sprintf("/%s/%s/%s", r.Class, r.TargetID, r.Property),
+	}
+
+	return uri.String()
+}

platform/dbops/binaries/weaviate-src/entities/schema/crossref/crossref_source_test.go

@@ -0,0 +1,169 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package crossref
+
+import (
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func Test_Source_ParsingFromString(t *testing.T) {
+	t.Run("from a local object ref that is well-formed", func(t *testing.T) {
+		uri := "weaviate://localhost/MyClassName/c2cd3f91-0160-477e-869a-8da8829e0a4d/myRefProp"
+		ref, err := ParseSource(uri)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, true)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "localhost")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+
+		t.Run("the class name is correct", func(t *testing.T) {
+			assert.Equal(t, ref.Class, schema.ClassName("MyClassName"))
+		})
+
+		t.Run("the property name is correct", func(t *testing.T) {
+			assert.Equal(t, ref.Property, schema.PropertyName("myRefProp"))
+		})
+
+		t.Run("assembling a new source and comparing if the match", func(t *testing.T) {
+			alt := NewSource("MyClassName", "myRefProp",
+				"c2cd3f91-0160-477e-869a-8da8829e0a4d")
+			assert.Equal(t, ref, alt)
+		})
+	})
+
+	t.Run("from a local action ref that is well-formed", func(t *testing.T) {
+		uri := "weaviate://localhost/MyActionClass/c2cd3f91-0160-477e-869a-8da8829e0a4d/myRefProp"
+		ref, err := ParseSource(uri)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, true)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "localhost")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+
+		t.Run("the class name is correct", func(t *testing.T) {
+			assert.Equal(t, ref.Class, schema.ClassName("MyActionClass"))
+		})
+
+		t.Run("the property name is correct", func(t *testing.T) {
+			assert.Equal(t, ref.Property, schema.PropertyName("myRefProp"))
+		})
+
+		t.Run("assembling a new source and comparing if the match", func(t *testing.T) {
+			alt := NewSource("MyActionClass", "myRefProp",
+				"c2cd3f91-0160-477e-869a-8da8829e0a4d")
+			assert.Equal(t, ref, alt)
+		})
+	})
+
+	t.Run("from a network action ref that is well-formed", func(t *testing.T) {
+		uri := "weaviate://another-weaviate/SomeActionClass/c2cd3f91-0160-477e-869a-8da8829e0a4d/myRefProp"
+		ref, err := ParseSource(uri)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, false)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "another-weaviate")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+
+		t.Run("the class name is correct", func(t *testing.T) {
+			assert.Equal(t, ref.Class, schema.ClassName("SomeActionClass"))
+		})
+
+		t.Run("the property name is correct", func(t *testing.T) {
+			assert.Equal(t, ref.Property, schema.PropertyName("myRefProp"))
+		})
+	})
+
+	t.Run("with formatting errors", func(t *testing.T) {
+		type testCaseError struct {
+			name string
+			uri  string
+		}
+
+		tests := []testCaseError{
+			{
+				name: "with an invalid URL",
+				uri:  "i:am:not:a:url",
+			},
+			{
+				name: "with too few path segments",
+				uri:  "weaviate://localhost/SomeClass",
+			},
+			{
+				name: "with too many path segments",
+				uri:  "weaviate://localhost/SomeClass/c2cd3f91-0160-477e-869a-8da8829e0a4d/myRefProp/somethingElse",
+			},
+			{
+				name: "without a property",
+				uri:  "weaviate://localhost/SomeClass/c2cd3f91-0160-477e-869a-8da8829e0a4d/",
+			},
+			{
+				name: "with an invalid uuid",
+				uri:  "weaviate://localhost/SomeClass/c2cd3f91-iSneakedInHere-477e-869a-8da8829e0a4d",
+			},
+			{
+				name: "with an invalid kind", // was /humans/SomeClass
+				uri:  "weaviate://localhost/SomeClass/c2cd3f91-0160-477e-869a-8da8829e0a4d",
+			},
+			{
+				name: "with a lowercased class name",
+				uri:  "weaviate://localhost/someClass/c2cd3f91-0160-477e-869a-8da8829e0a4d/myRefProp",
+			},
+		}
+
+		for _, test := range tests {
+			t.Run(test.name, func(t *testing.T) {
+				_, err := ParseSource(test.uri)
+				assert.NotNil(t, err, test.name)
+			})
+		}
+	})
+}
+
+func Test_Source_GenerateString(t *testing.T) {
+	uri := "weaviate://localhost/MyClass/c2cd3f91-0160-477e-869a-8da8829e0a4d/myRefProp"
+	ref, err := ParseSource(uri)
+
+	require.Nil(t, err, "should not error")
+	assert.Equal(t, uri, ref.String(), "should be the same as the input string")
+}

platform/dbops/binaries/weaviate-src/entities/schema/crossref/crossref_test.go

@@ -0,0 +1,233 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package crossref
+
+import (
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func TestParseCrossReference(t *testing.T) {
+	ref := Ref{
+		Local:    true,
+		PeerName: _LocalHost,
+		TargetID: "c2cd3f91-0160-477e-869a-8da8829e0a4d",
+		Class:    "class",
+	}
+	tests := []struct {
+		beacon string
+		ref    Ref
+		ok     bool
+	}{
+		{
+			beacon: "weaviate://localhost/class/c2cd3f91-0160-477e-869a-8da8829e0a4d",
+			ref:    ref,
+			ok:     true,
+		},
+		{
+			beacon: "weaviate://remote/class/c2cd3f91-0160-477e-869a-8da8829e0a4d",
+			ref:    Ref{false, "remote", ref.TargetID, "class"},
+			ok:     true,
+		},
+		{
+			beacon: "weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d",
+			ref:    Ref{true, _LocalHost, ref.TargetID, ""},
+			ok:     true,
+		},
+		{
+			beacon: "weaviate://remote/c2cd3f91-0160-477e-869a-8da8829e0a4d",
+			ref:    Ref{false, "remote", ref.TargetID, ""},
+			ok:     true,
+		},
+		{
+			beacon: "weaviate://localhost/class/c2cd3f91-0160-477e-869a-8da8829e0a4d/i-shouldnt-be-here",
+		},
+		{
+			beacon: "weaviate://localhost/class/invalid-id",
+		},
+		{
+			beacon: "weaviate://localhost/class",
+		},
+		{
+			beacon: "weaviate://localhost",
+		},
+		{
+			beacon: "i:am:not:a:url",
+		},
+	}
+	for i, tc := range tests {
+		got, err := Parse(tc.beacon)
+		if (err == nil) != tc.ok {
+			t.Errorf("%d - Parse(%s) error %v error expected: %t", i, tc.beacon, err, tc.ok)
+			continue
+		}
+		if err != nil {
+			continue
+		}
+		if *got != tc.ref {
+			t.Errorf("%d - Parse(%s) got %v want %v", i, tc.beacon, *got, tc.ref)
+		}
+		if beacon := got.String(); beacon != tc.beacon {
+			t.Errorf("beacon expected: %v want %v", tc.beacon, beacon)
+		}
+	}
+}
+
+func TestSingleRef(t *testing.T) {
+	ref := NewLocalhost("class", "c2cd3f91-0160-477e-869a-8da8829e0a4d")
+	expected := &models.SingleRef{
+		Beacon: strfmt.URI("weaviate://localhost/class/c2cd3f91-0160-477e-869a-8da8829e0a4d"),
+	}
+	sref := ref.SingleRef()
+	assert.Equal(t, expected, sref, "should create a singleRef")
+	xref, _ := ParseSingleRef(sref)
+	assert.Equal(t, ref, xref)
+}
+
+func Test_ParsingFromStringDeprecated(t *testing.T) {
+	t.Run("from a local object ref that is well-formed", func(t *testing.T) {
+		uri := "weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d"
+		ref, err := Parse(uri)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, true)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "localhost")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+	})
+
+	t.Run("from a local action ref that is well-formed", func(t *testing.T) {
+		uri := "weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d"
+		ref, err := Parse(uri)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, true)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "localhost")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+	})
+
+	t.Run("from a network action ref that is well-formed", func(t *testing.T) {
+		uri := "weaviate://another-weaviate/c2cd3f91-0160-477e-869a-8da8829e0a4d"
+		ref, err := Parse(uri)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, false)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "another-weaviate")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+	})
+
+	t.Run("with formatting errors", func(t *testing.T) {
+		type testCaseError struct {
+			name string
+			uri  string
+		}
+
+		tests := []testCaseError{
+			{
+				name: "with an invalid URL",
+				uri:  "i:am:not:a:url",
+			},
+			{
+				name: "with too few path segments",
+				uri:  "weaviate://localhost",
+			},
+			{
+				name: "with too many path segments",
+				uri:  "weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d/i-shouldnt-be-here",
+			},
+			{
+				name: "with an invalid uuid",
+				uri:  "weaviate://localhost/c2cd3f91-iSneakedInHere-477e-869a-8da8829e0a4d",
+			},
+		}
+
+		for _, test := range tests {
+			t.Run(test.name, func(t *testing.T) {
+				_, err := Parse(test.uri)
+				assert.NotNil(t, err, test.name)
+			})
+		}
+	})
+}
+
+func Test_ParsingFromSingleRefDeprecated(t *testing.T) {
+	t.Run("from a local object ref that is well-formed", func(t *testing.T) {
+		uri := strfmt.URI("weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d")
+		singleRef := &models.SingleRef{
+			Beacon: uri,
+		}
+		ref, err := ParseSingleRef(singleRef)
+
+		require.Nil(t, err, "should not error")
+
+		t.Run("is a local ref", func(t *testing.T) {
+			assert.Equal(t, ref.Local, true)
+		})
+
+		t.Run("peerName points to localhost", func(t *testing.T) {
+			assert.Equal(t, ref.PeerName, "localhost")
+		})
+
+		t.Run("id points correctly", func(t *testing.T) {
+			assert.Equal(t, ref.TargetID, strfmt.UUID("c2cd3f91-0160-477e-869a-8da8829e0a4d"))
+		})
+	})
+}
+
+func Test_GenerateStringDeprecated(t *testing.T) {
+	uri := "weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d"
+	ref, err := Parse(uri)
+
+	require.Nil(t, err, "should not error")
+	assert.Equal(t, uri, ref.String(), "should be the same as the input string")
+}
+
+func Test_DeprecatedSingleRef(t *testing.T) {
+	uri := "weaviate://localhost/c2cd3f91-0160-477e-869a-8da8829e0a4d"
+	ref, err := Parse(uri)
+	expectedResult := &models.SingleRef{
+		Beacon: strfmt.URI(uri),
+	}
+
+	require.Nil(t, err, "should not error")
+	assert.Equal(t, expectedResult, ref.SingleRef(), "should create a singleRef (api construct)")
+}

platform/dbops/binaries/weaviate-src/entities/schema/test_utils/nested_properties.go

@@ -0,0 +1,45 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func AssertNestedPropsMatch(t *testing.T, nestedPropsA, nestedPropsB []*models.NestedProperty) {
+	require.Len(t, nestedPropsB, len(nestedPropsA), "nestedProps: different length")
+
+	npMap := map[string]int{}
+	for index, np := range nestedPropsA {
+		npMap[np.Name] = index
+	}
+
+	for _, npB := range nestedPropsB {
+		require.Contains(t, npMap, npB.Name)
+		npA := nestedPropsA[npMap[npB.Name]]
+
+		assert.Equal(t, npA.DataType, npB.DataType)
+		assert.Equal(t, npA.IndexFilterable, npB.IndexFilterable)
+		assert.Equal(t, npA.IndexSearchable, npB.IndexSearchable)
+		assert.Equal(t, npA.IndexRangeFilters, npB.IndexRangeFilters)
+		assert.Equal(t, npA.Tokenization, npB.Tokenization)
+
+		if _, isNested := schema.AsNested(npA.DataType); isNested {
+			AssertNestedPropsMatch(t, npA.NestedProperties, npB.NestedProperties)
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/entities/schema/test_utils/properties.go

@@ -0,0 +1,45 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func AssertPropsMatch(t *testing.T, propsA, propsB []*models.Property) {
+	require.Len(t, propsB, len(propsA), "props: different length")
+
+	pMap := map[string]int{}
+	for idx, p := range propsA {
+		pMap[p.Name] = idx
+	}
+
+	for _, pB := range propsB {
+		require.Contains(t, pMap, pB.Name)
+		pA := propsA[pMap[pB.Name]]
+
+		assert.Equal(t, pA.DataType, pB.DataType)
+		assert.Equal(t, pA.IndexFilterable, pB.IndexFilterable)
+		assert.Equal(t, pA.IndexSearchable, pB.IndexSearchable)
+		assert.Equal(t, pA.IndexRangeFilters, pB.IndexRangeFilters)
+		assert.Equal(t, pA.Tokenization, pB.Tokenization)
+
+		if _, isNested := schema.AsNested(pA.DataType); isNested {
+			AssertNestedPropsMatch(t, pA.NestedProperties, pB.NestedProperties)
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/entities/storobj/enrich_schema_datatypes.go

@@ -0,0 +1,409 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package storobj
+
+import (
+	"fmt"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func enrichSchemaTypes(schema map[string]interface{}, ofNestedProp bool) error {
+	if schema == nil {
+		return nil
+	}
+
+	for propName, value := range schema {
+		switch typed := value.(type) {
+		case []interface{}:
+			if isArrayValue(typed) {
+				switch typed[0].(type) {
+				case float64:
+					parsed, err := parseNumberArrayValue(typed)
+					if err != nil {
+						return errors.Wrapf(err, "property %q of type string array", propName)
+					}
+
+					schema[propName] = parsed
+				case bool:
+					parsed, err := parseBoolArrayValue(typed)
+					if err != nil {
+						return errors.Wrapf(err, "property %q of type boolean array", propName)
+					}
+
+					schema[propName] = parsed
+				default:
+					parsed, err := parseStringArrayValue(typed)
+					if err != nil {
+						return errors.Wrapf(err, "property %q of type string array", propName)
+					}
+
+					schema[propName] = parsed
+				}
+			} else if len(typed) == 0 {
+				// empty arrays. Here we use []interface{} as a placeholder
+				// type for an empty array, since we cannot determine its
+				// actual type. in the future, we should persist the schema
+				// property type information alongside the value to avoid
+				// this situation
+				schema[propName] = typed
+			} else {
+				// nested properties does not support refs
+				if !ofNestedProp {
+					parsed, err := parseCrossRef(typed)
+					if err == nil {
+						schema[propName] = parsed
+						continue
+					}
+				}
+				// apperently object[]
+				for i := range typed {
+					t2, ok := typed[i].(map[string]interface{})
+					if !ok {
+						return fmt.Errorf("expected element [%d] of '%s' to be map, %T found", i, propName, typed[i])
+					}
+					enrichSchemaTypes(t2, true)
+				}
+				schema[propName] = typed
+			}
+		case map[string]interface{}:
+			parsed, err := parseMapProp(typed, ofNestedProp)
+			if err != nil {
+				return errors.Wrapf(err, "property %q of type map", propName)
+			}
+
+			schema[propName] = parsed
+		default:
+			continue
+		}
+	}
+
+	return nil
+}
+
+// nested properties does not support phone or geo data types
+func parseMapProp(input map[string]interface{}, ofNestedProp bool) (interface{}, error) {
+	if !ofNestedProp && isGeoProp(input) {
+		return parseGeoProp(input)
+	}
+	if !ofNestedProp && isPhoneProp(input) {
+		return parsePhoneNumber(input)
+	}
+	// apparently object
+	err := enrichSchemaTypes(input, true)
+	return input, err
+}
+
+func isGeoProp(input map[string]interface{}) bool {
+	expectedProps := []string{"latitude", "longitude"}
+
+	if len(input) != len(expectedProps) {
+		return false
+	}
+	for _, prop := range expectedProps {
+		if _, ok := input[prop]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func isPhoneProp(input map[string]interface{}) bool {
+	validExpectedProps := [][]string{
+		{"input", "internationalFormatted", "nationalFormatted", "national", "countryCode", "valid"},
+		{"input", "internationalFormatted", "nationalFormatted", "national", "countryCode", "valid", "defaultCountry"},
+		{"input", "internationalFormatted", "nationalFormatted", "national", "countryCode"},
+		{"input", "internationalFormatted", "nationalFormatted", "national", "countryCode", "defaultCountry"},
+	}
+
+	for _, expectedProps := range validExpectedProps {
+		match := true
+		if len(expectedProps) != len(input) {
+			match = false
+		} else {
+			for _, prop := range expectedProps {
+				if _, ok := input[prop]; !ok {
+					match = false
+					break
+				}
+			}
+		}
+		if match {
+			return true
+		}
+	}
+	return false
+}
+
+func parseGeoProp(input map[string]interface{}) (*models.GeoCoordinates, error) {
+	latFloat, ok := input["latitude"].(float64)
+	if !ok {
+		return nil, fmt.Errorf("explected lat to be float64, but is %T", input["latitude"])
+	}
+
+	lonFloat, ok := input["longitude"].(float64)
+	if !ok {
+		return nil, fmt.Errorf("explected lon to be float64, but is %T", input["longitude"])
+	}
+
+	return &models.GeoCoordinates{
+		Latitude:  ptFloat32(float32(latFloat)),
+		Longitude: ptFloat32(float32(lonFloat)),
+	}, nil
+}
+
+func ptFloat32(in float32) *float32 {
+	return &in
+}
+
+func parsePhoneNumber(input map[string]interface{}) (*models.PhoneNumber, error) {
+	out := &models.PhoneNumber{}
+
+	phoneInput, err := extractStringFromMap(input, "input")
+	if err != nil {
+		return nil, err
+	}
+	out.Input = phoneInput
+
+	international, err := extractStringFromMap(input, "internationalFormatted")
+	if err != nil {
+		return nil, err
+	}
+	out.InternationalFormatted = international
+
+	nationalFormatted, err := extractStringFromMap(input, "nationalFormatted")
+	if err != nil {
+		return nil, err
+	}
+	out.NationalFormatted = nationalFormatted
+
+	national, err := extractNumberFromMap(input, "national")
+	if err != nil {
+		return nil, err
+	}
+	out.National = uint64(national)
+
+	countryCode, err := extractNumberFromMap(input, "countryCode")
+	if err != nil {
+		return nil, err
+	}
+	out.CountryCode = uint64(countryCode)
+
+	defaultCountry, err := extractStringFromMap(input, "defaultCountry")
+	if err != nil {
+		return nil, err
+	}
+	out.DefaultCountry = defaultCountry
+
+	valid, err := extractBoolFromMap(input, "valid")
+	if err != nil {
+		return nil, err
+	}
+	out.Valid = valid
+
+	return out, nil
+}
+
+func extractNumberFromMap(input map[string]interface{}, key string) (float64, error) {
+	field, ok := input[key]
+	if ok {
+		asFloat, ok := field.(float64)
+		if !ok {
+			return 0, fmt.Errorf("expected '%s' to be float64, but is %T", key, field)
+		}
+
+		return asFloat, nil
+	}
+	return 0, nil
+}
+
+func extractStringFromMap(input map[string]interface{}, key string) (string, error) {
+	field, ok := input[key]
+	if ok {
+		asString, ok := field.(string)
+		if !ok {
+			return "", fmt.Errorf("expected '%s' to be string, but is %T", key, field)
+		}
+
+		return asString, nil
+	}
+	return "", nil
+}
+
+func extractBoolFromMap(input map[string]interface{}, key string) (bool, error) {
+	field, ok := input[key]
+	if ok {
+		asBool, ok := field.(bool)
+		if !ok {
+			return false, fmt.Errorf("expected '%s' to be bool, but is %T", key, field)
+		}
+
+		return asBool, nil
+	}
+	return false, nil
+}
+
+func isArrayValue(value []interface{}) bool {
+	if len(value) > 0 {
+		_, ok := value[0].(map[string]interface{})
+		return !ok
+	}
+	return false
+}
+
+func parseStringArrayValue(value []interface{}) ([]string, error) {
+	parsed := make([]string, len(value))
+	for i := range value {
+		asString, ok := value[i].(string)
+		if !ok {
+			return nil, fmt.Errorf("string array: expected element %d to be string - got %T", i, value[i])
+		}
+		parsed[i] = asString
+	}
+	return parsed, nil
+}
+
+func parseNumberArrayValue(value []interface{}) ([]float64, error) {
+	parsed := make([]float64, len(value))
+	for i := range value {
+		asFloat, ok := value[i].(float64)
+		if !ok {
+			return nil, fmt.Errorf("number array: expected element %d to be float - got %T", i, value[i])
+		}
+		parsed[i] = asFloat
+	}
+	return parsed, nil
+}
+
+func parseBoolArrayValue(value []interface{}) ([]bool, error) {
+	parsed := make([]bool, len(value))
+	for i := range value {
+		asBool, ok := value[i].(bool)
+		if !ok {
+			return nil, fmt.Errorf("boolean array: expected element %d to be bool - got %T", i, value[i])
+		}
+		parsed[i] = asBool
+	}
+	return parsed, nil
+}
+
+func parseCrossRef(value []interface{}) (models.MultipleRef, error) {
+	parsed := make(models.MultipleRef, len(value))
+	for i, elem := range value {
+		asMap, ok := elem.(map[string]interface{})
+		if !ok {
+			return nil, fmt.Errorf("crossref: expected element %d to be map - got %T", i, elem)
+		}
+
+		beacon, ok := asMap["beacon"]
+		if !ok {
+			return nil, fmt.Errorf("crossref: expected element %d to have key %q - got %v", i, "beacon", elem)
+		}
+
+		beaconStr, ok := beacon.(string)
+		if !ok {
+			return nil, fmt.Errorf("crossref: expected element %d.beacon to be string - got %T", i, beacon)
+		}
+
+		parsed[i] = &models.SingleRef{
+			Beacon: strfmt.URI(beaconStr),
+		}
+
+		c, ok := asMap["classification"]
+		if ok {
+			classification, err := parseRefClassificationMeta(c)
+			if err != nil {
+				return nil, errors.Wrap(err, "crossref: parse classifiation meta")
+			}
+
+			parsed[i].Classification = classification
+		}
+	}
+
+	return parsed, nil
+}
+
+func parseRefClassificationMeta(in interface{}) (*models.ReferenceMetaClassification, error) {
+	out := &models.ReferenceMetaClassification{}
+	asMap, ok := in.(map[string]interface{})
+	if !ok {
+		return nil, fmt.Errorf("expected classification to be map - got %T", in)
+	}
+
+	if cod, err := extractFloat64(asMap, "closestOverallDistance"); err != nil {
+		return nil, err
+	} else {
+		out.ClosestOverallDistance = cod
+	}
+
+	if mwd, err := extractFloat64(asMap, "meanWinningDistance"); err != nil {
+		return nil, err
+	} else {
+		out.WinningDistance = mwd // deprecated remove in 0.23.0
+		out.MeanWinningDistance = mwd
+	}
+
+	if cwd, err := extractFloat64(asMap, "closestWinningDistance"); err != nil {
+		return nil, err
+	} else {
+		out.ClosestWinningDistance = cwd
+	}
+
+	if mcd, err := extractFloat64(asMap, "meanLosingDistance"); err != nil {
+		return nil, err
+	} else {
+		out.LosingDistance = &mcd // deprecated remove in 0.23.0
+		out.MeanLosingDistance = &mcd
+	}
+
+	if ccd, err := extractFloat64(asMap, "closestLosingDistance"); err != nil {
+		return nil, err
+	} else {
+		out.ClosestLosingDistance = &ccd
+	}
+
+	if oc, err := extractFloat64(asMap, "overallCount"); err != nil {
+		return nil, err
+	} else {
+		out.OverallCount = int64(oc)
+	}
+
+	if wc, err := extractFloat64(asMap, "winningCount"); err != nil {
+		return nil, err
+	} else {
+		out.WinningCount = int64(wc)
+	}
+
+	if lc, err := extractFloat64(asMap, "losingCount"); err != nil {
+		return nil, err
+	} else {
+		out.LosingCount = int64(lc)
+	}
+
+	return out, nil
+}
+
+func extractFloat64(source map[string]interface{}, key string) (float64, error) {
+	value, ok := source[key]
+	if !ok {
+		return 0, nil
+	}
+
+	asFloat, ok := value.(float64)
+	if !ok {
+		return 0, fmt.Errorf("expected %s to be float64 - got %T", key, value)
+	}
+
+	return asFloat, nil
+}

platform/dbops/binaries/weaviate-src/entities/storobj/errors.go

@@ -0,0 +1,30 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package storobj
+
+import "fmt"
+
+type ErrNotFound struct {
+	DocID       uint64
+	OriginalMsg string
+}
+
+func NewErrNotFoundf(docID uint64, msg string, args ...interface{}) error {
+	return ErrNotFound{
+		DocID:       docID,
+		OriginalMsg: fmt.Sprintf(msg, args...),
+	}
+}
+
+func (err ErrNotFound) Error() string {
+	return fmt.Sprintf("no object found for doc id %d: %s", err.DocID, err.OriginalMsg)
+}

platform/dbops/binaries/weaviate-src/entities/storobj/parse_single_object.go

@@ -0,0 +1,173 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package storobj
+
+import (
+	"bytes"
+	"encoding/binary"
+	"strconv"
+
+	"github.com/buger/jsonparser"
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+)
+
+func ParseAndExtractProperty(data []byte, propName string) ([]string, bool, error) {
+	if propName == "id" || propName == "_id" {
+		return extractID(data)
+	}
+	if propName == "_creationTimeUnix" {
+		return extractCreationTimeUnix(data)
+	}
+	if propName == "_lastUpdateTimeUnix" {
+		return extractLastUpdateTimeUnix(data)
+	}
+	return ParseAndExtractTextProp(data, propName)
+}
+
+func ParseAndExtractTextProp(data []byte, propName string) ([]string, bool, error) {
+	vals := []string{}
+	err := parseAndExtractValueProp(data, propName, func(value []byte) {
+		vals = append(vals, string(value))
+	})
+	if err != nil {
+		return nil, false, err
+	}
+	return vals, true, nil
+}
+
+func ParseAndExtractNumberArrayProp(data []byte, propName string) ([]float64, bool, error) {
+	vals := []float64{}
+	err := parseAndExtractValueProp(data, propName, func(value []byte) {
+		vals = append(vals, mustExtractNumber(value))
+	})
+	if err != nil {
+		return nil, false, err
+	}
+	return vals, true, nil
+}
+
+func ParseAndExtractBoolArrayProp(data []byte, propName string) ([]bool, bool, error) {
+	vals := []bool{}
+	err := parseAndExtractValueProp(data, propName, func(value []byte) {
+		vals = append(vals, mustExtractBool(value))
+	})
+	if err != nil {
+		return nil, false, err
+	}
+	return vals, true, nil
+}
+
+func parseAndExtractValueProp(data []byte, propName string, valueFn func(value []byte)) error {
+	propsBytes, err := extractPropsBytes(data)
+	if err != nil {
+		return err
+	}
+
+	val, t, _, err := jsonparser.Get(propsBytes, propName)
+	// Some objects can have nil as value for the property, in this case skip the object
+	if err != nil {
+		if err.Error() == "Key path not found" {
+			return nil
+		}
+		return err
+	}
+
+	if t == jsonparser.Array {
+		jsonparser.ArrayEach(val, func(value []byte, dataType jsonparser.ValueType, offset int, err error) {
+			valueFn(value)
+		})
+	} else {
+		valueFn(val)
+	}
+
+	return nil
+}
+
+func mustExtractNumber(value []byte) float64 {
+	number, err := strconv.ParseFloat(string(value), 64)
+	if err != nil {
+		panic("not a float64")
+	}
+	return number
+}
+
+func mustExtractBool(value []byte) bool {
+	boolVal, err := strconv.ParseBool(string(value))
+	if err != nil {
+		panic("not a bool")
+	}
+	return boolVal
+}
+
+func extractID(data []byte) ([]string, bool, error) {
+	start := 1 + 8 + 1
+	end := start + 16
+	if len(data) > end {
+		uuidParsed, err := uuid.FromBytes(data[start:end])
+		if err != nil {
+			return nil, false, errors.New("cannot parse id property")
+		}
+		return []string{uuidParsed.String()}, true, nil
+	}
+	return nil, false, errors.New("id property not found")
+}
+
+func extractCreationTimeUnix(data []byte) ([]string, bool, error) {
+	start := 1 + 8 + 1 + 16
+	end := start + 8
+	if len(data) > end {
+		return extractTimeUnix(data[start:end], "_creationTimeUnix")
+	}
+	return nil, false, errors.New("_creationTimeUnix property not found")
+}
+
+func extractLastUpdateTimeUnix(data []byte) ([]string, bool, error) {
+	start := 1 + 8 + 1 + 16 + 8
+	end := start + 8
+	if len(data) > end {
+		return extractTimeUnix(data[start:end], "_lastUpdateTimeUnix")
+	}
+	return nil, false, errors.New("_lastUpdateTimeUnix property not found")
+}
+
+func extractTimeUnix(data []byte, propertyName string) ([]string, bool, error) {
+	var timeUnix int64
+	r := bytes.NewReader(data)
+	if err := binary.Read(r, binary.LittleEndian, &timeUnix); err != nil {
+		return nil, false, errors.Errorf("cannot parse %s property", propertyName)
+	}
+	return []string{strconv.FormatInt(timeUnix, 10)}, true, nil
+}
+
+func extractPropsBytes(data []byte) ([]byte, error) {
+	version := uint8(data[0])
+	if version != 1 {
+		return nil, errors.Errorf("unsupported binary marshaller version %d", version)
+	}
+
+	vecLen := binary.LittleEndian.Uint16(data[discardBytesPreVector : discardBytesPreVector+2])
+
+	classNameStart := int64(discardBytesPreVector) + 2 + int64(vecLen)*4
+
+	classNameLen := binary.LittleEndian.Uint16(data[classNameStart : classNameStart+2])
+
+	propsLenStart := classNameStart + 2 + int64(classNameLen)
+	propsLen := binary.LittleEndian.Uint32(data[propsLenStart : propsLenStart+4])
+
+	start := int64(propsLenStart + 4)
+	end := start + int64(propsLen)
+
+	return data[start:end], nil
+}
+
+const discardBytesPreVector = 1 + 8 + 1 + 16 + 8 + 8

platform/dbops/binaries/weaviate-src/entities/storobj/storage_object.go

@@ -0,0 +1,1643 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package storobj
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"runtime"
+
+	"github.com/buger/jsonparser"
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/vmihailenco/msgpack/v5"
+	"github.com/weaviate/weaviate/entities/additional"
+	errwrap "github.com/weaviate/weaviate/entities/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/search"
+	"github.com/weaviate/weaviate/usecases/byteops"
+)
+
+var bufPool *bufferPool
+
+type Vectors map[string][]float32
+
+func init() {
+	// a 10kB buffer should be large enough for typical cases, it can fit a
+	// 1536d uncompressed vector and about 3kB of object payload. If the
+	// initial size is not large enoug, the caller can always allocate a larger
+	// buffer and return that to the pool instead.
+	bufPool = newBufferPool(10 * 1024)
+}
+
+type Object struct {
+	MarshallerVersion uint8
+	Object            models.Object `json:"object"`
+	Vector            []float32     `json:"vector"`
+	VectorLen         int           `json:"-"`
+	BelongsToNode     string        `json:"-"`
+	BelongsToShard    string        `json:"-"`
+	IsConsistent      bool          `json:"-"`
+	DocID             uint64
+	Vectors           map[string][]float32   `json:"vectors"`
+	MultiVectors      map[string][][]float32 `json:"multivectors"`
+}
+
+func New(docID uint64) *Object {
+	return &Object{
+		MarshallerVersion: 1,
+		DocID:             docID,
+	}
+}
+
+// TODO: temporary solution
+func FromObject(object *models.Object, vector []float32, vectors map[string][]float32, multivectors map[string][][]float32) *Object {
+	// clear out nil entries of properties to make sure leaving a property out and setting it nil is identical
+	properties, ok := object.Properties.(map[string]interface{})
+	if ok {
+		for key, prop := range properties {
+			if prop == nil {
+				delete(properties, key)
+			}
+		}
+		object.Properties = properties
+	}
+
+	var vecs map[string][]float32
+	if vectors != nil {
+		vecs = make(map[string][]float32)
+		for targetVector, vector := range vectors {
+			vecs[targetVector] = vector
+		}
+	}
+
+	var multiVectors map[string][][]float32
+	if multivectors != nil {
+
+		multiVectors = make(map[string][][]float32)
+		for targetVector, vectors := range multivectors {
+			multiVectors[targetVector] = vectors
+		}
+	}
+
+	return &Object{
+		Object:            *object,
+		Vector:            vector,
+		MarshallerVersion: 1,
+		VectorLen:         len(vector),
+		Vectors:           vecs,
+		MultiVectors:      multiVectors,
+	}
+}
+
+func FromBinary(data []byte) (*Object, error) {
+	ko := &Object{}
+	if err := ko.UnmarshalBinary(data); err != nil {
+		return nil, err
+	}
+
+	return ko, nil
+}
+
+func FromBinaryUUIDOnly(data []byte) (*Object, error) {
+	ko := &Object{}
+
+	rw := byteops.NewReadWriter(data)
+	version := rw.ReadUint8()
+	if version != 1 {
+		return nil, errors.Errorf("unsupported binary marshaller version %d", version)
+	}
+
+	ko.MarshallerVersion = version
+
+	ko.DocID = rw.ReadUint64()
+	rw.MoveBufferPositionForward(1) // ignore kind-byte
+	uuidObj, err := uuid.FromBytes(rw.ReadBytesFromBuffer(16))
+	if err != nil {
+		return nil, fmt.Errorf("parse uuid: %w", err)
+	}
+	ko.Object.ID = strfmt.UUID(uuidObj.String())
+
+	ko.Object.CreationTimeUnix = int64(rw.ReadUint64())
+	ko.Object.LastUpdateTimeUnix = int64(rw.ReadUint64())
+
+	vecLen := rw.ReadUint16()
+	rw.MoveBufferPositionForward(uint64(vecLen * 4))
+	classNameLen := rw.ReadUint16()
+
+	ko.Object.Class = string(rw.ReadBytesFromBuffer(uint64(classNameLen)))
+
+	return ko, nil
+}
+
+func FromBinaryOptional(data []byte,
+	addProp additional.Properties, properties *PropertyExtraction,
+) (*Object, error) {
+	ko := &Object{}
+
+	rw := byteops.NewReadWriter(data)
+	ko.MarshallerVersion = rw.ReadUint8()
+	if ko.MarshallerVersion != 1 {
+		return nil, errors.Errorf("unsupported binary marshaller version %d", ko.MarshallerVersion)
+	}
+	ko.DocID = rw.ReadUint64()
+	rw.MoveBufferPositionForward(1) // ignore kind-byte
+	uuidObj, err := uuid.FromBytes(rw.ReadBytesFromBuffer(16))
+	if err != nil {
+		return nil, fmt.Errorf("parse uuid: %w", err)
+	}
+	uuidParsed := strfmt.UUID(uuidObj.String())
+
+	createTime := int64(rw.ReadUint64())
+	updateTime := int64(rw.ReadUint64())
+	vectorLength := rw.ReadUint16()
+	// The vector length should always be returned (for usage metrics purposes) even if the vector itself is skipped
+	ko.VectorLen = int(vectorLength)
+	if addProp.Vector {
+		ko.Object.Vector = make([]float32, vectorLength)
+		vectorBytes := rw.ReadBytesFromBuffer(uint64(vectorLength) * 4)
+		for i := 0; i < int(vectorLength); i++ {
+			bits := binary.LittleEndian.Uint32(vectorBytes[i*4 : (i+1)*4])
+			ko.Object.Vector[i] = math.Float32frombits(bits)
+		}
+	} else {
+		rw.MoveBufferPositionForward(uint64(vectorLength) * 4)
+		ko.Object.Vector = nil
+	}
+	ko.Vector = ko.Object.Vector
+
+	classNameLen := rw.ReadUint16()
+	className := string(rw.ReadBytesFromBuffer(uint64(classNameLen)))
+
+	propLength := rw.ReadUint32()
+	var props []byte
+	if addProp.NoProps {
+		rw.MoveBufferPositionForward(uint64(propLength))
+	} else {
+		props = rw.ReadBytesFromBuffer(uint64(propLength))
+	}
+
+	var meta []byte
+	metaLength := rw.ReadUint32()
+	if addProp.Classification || len(addProp.ModuleParams) > 0 {
+		meta = rw.ReadBytesFromBuffer(uint64(metaLength))
+	} else {
+		rw.MoveBufferPositionForward(uint64(metaLength))
+	}
+
+	vectorWeightsLength := rw.ReadUint32()
+	vectorWeights := rw.ReadBytesFromBuffer(uint64(vectorWeightsLength))
+
+	if len(addProp.Vectors) > 0 {
+		vectors, err := unmarshalTargetVectors(&rw)
+		if err != nil {
+			return nil, err
+		}
+		ko.Vectors = vectors
+
+		if vectors != nil {
+			// If parseObject is called, ko.Object will be overwritten making this effectively a
+			// no-op, but I'm leaving it here for now to avoid breaking anything.
+			ko.Object.Vectors = make(models.Vectors)
+			for vecName, vec := range vectors {
+				ko.Object.Vectors[vecName] = vec
+			}
+		}
+	} else {
+		if rw.Position < uint64(len(rw.Buffer)) {
+			_ = rw.ReadBytesFromBufferWithUint32LengthIndicator()
+			targetVectorsSegmentLength := rw.ReadUint32()
+			pos := rw.Position
+			rw.MoveBufferToAbsolutePosition(pos + uint64(targetVectorsSegmentLength))
+		}
+	}
+
+	if rw.Position < uint64(len(rw.Buffer)) && len(addProp.Vectors) > 0 {
+		vectorNamesToUnmarshal := map[string]interface{}{}
+		for _, name := range addProp.Vectors {
+			vectorNamesToUnmarshal[name] = nil
+		}
+		multiVectors, err := unmarshalMultiVectors(&rw, vectorNamesToUnmarshal)
+		if err != nil {
+			return nil, err
+		}
+		ko.MultiVectors = multiVectors
+
+		if multiVectors != nil {
+			// If parseObject is called, ko.Object will be overwritten making this effectively a
+			// no-op, but I'm leaving it here to match the target vector behavior.
+			if ko.Object.Vectors == nil {
+				ko.Object.Vectors = make(models.Vectors)
+			}
+			for vecName, vec := range multiVectors {
+				// assume at this level target vectors and multi vectors won't have the same name
+				ko.Object.Vectors[vecName] = vec
+			}
+		}
+	}
+
+	// some object members need additional "enrichment". Only do this if necessary, ie if they are actually present
+	if len(props) > 0 ||
+		len(meta) > 0 ||
+		vectorWeightsLength > 0 &&
+			!( // if the length is 4 and the encoded value is "null" (in ascii), vectorweights are not actually present
+			vectorWeightsLength == 4 &&
+				vectorWeights[0] == 110 && // n
+				vectorWeights[1] == 117 && // u
+				vectorWeights[2] == 108 && // l
+				vectorWeights[3] == 108) { // l
+
+		if err := ko.parseObject(
+			uuidParsed,
+			createTime,
+			updateTime,
+			className,
+			props,
+			meta,
+			vectorWeights,
+			properties,
+			propLength,
+		); err != nil {
+			return nil, errors.Wrap(err, "parse")
+		}
+	} else {
+		ko.Object.ID = uuidParsed
+		ko.Object.CreationTimeUnix = createTime
+		ko.Object.LastUpdateTimeUnix = updateTime
+		ko.Object.Class = className
+	}
+
+	return ko, nil
+}
+
+type PropertyExtraction struct {
+	PropertyPaths [][]string
+}
+
+func NewPropExtraction() *PropertyExtraction {
+	return &PropertyExtraction{
+		PropertyPaths: [][]string{},
+	}
+}
+
+func (pe *PropertyExtraction) Add(props ...string) *PropertyExtraction {
+	for i := range props {
+		pe.PropertyPaths = append(pe.PropertyPaths, []string{props[i]})
+	}
+	return pe
+}
+
+type bucket interface {
+	GetBySecondary(int, []byte) ([]byte, error)
+	GetBySecondaryWithBuffer(int, []byte, []byte) ([]byte, []byte, error)
+}
+
+func ObjectsByDocID(bucket bucket, ids []uint64,
+	additional additional.Properties, properties []string, logger logrus.FieldLogger,
+) ([]*Object, error) {
+	if len(ids) == 1 { // no need to try to run concurrently if there is just one result anyway
+		return objectsByDocIDSequential(bucket, ids, additional, properties)
+	}
+
+	return objectsByDocIDParallel(bucket, ids, additional, properties, logger)
+}
+
+func objectsByDocIDParallel(bucket bucket, ids []uint64,
+	addProp additional.Properties, properties []string, logger logrus.FieldLogger,
+) ([]*Object, error) {
+	parallel := 2 * runtime.GOMAXPROCS(0)
+
+	out := make([]*Object, len(ids))
+
+	chunkSize := max(int(math.Ceil(float64(len(ids))/float64(parallel))), 1)
+
+	eg := errwrap.NewErrorGroupWrapper(logger)
+
+	// prevent unbounded concurrency on massive chunks
+	// it's fine to use a multiple of GOMAXPROCS here, as the goroutines are
+	// mostly IO-bound
+	eg.SetLimit(parallel)
+	for chunk := 0; chunk < parallel; chunk++ {
+		start := chunk * chunkSize
+		end := start + chunkSize
+		if end > len(ids) {
+			end = len(ids)
+		}
+
+		if start >= len(ids) {
+			break
+		}
+
+		eg.Go(func() error {
+			objs, err := objectsByDocIDSequential(bucket, ids[start:end], addProp, properties)
+			if err != nil {
+				return err
+			}
+			copy(out[start:start+len(objs)], objs)
+			return nil
+		})
+	}
+
+	if err := eg.Wait(); err != nil {
+		return nil, err
+	}
+
+	// fix gaps in the output array
+	j := 0
+	for i := range out {
+		if out[i] != nil {
+			out[j] = out[i]
+			j++
+		}
+	}
+
+	return out[:j], nil
+}
+
+func objectsByDocIDSequential(bucket bucket, ids []uint64,
+	additional additional.Properties, properties []string,
+) ([]*Object, error) {
+	if bucket == nil {
+		return nil, fmt.Errorf("objects bucket not found")
+	}
+
+	var (
+		docIDBuf = make([]byte, 8)
+		out      = make([]*Object, len(ids))
+		i        = 0
+		lsmBuf   = bufPool.Get()
+	)
+
+	defer func() {
+		bufPool.Put(lsmBuf)
+	}()
+
+	var props *PropertyExtraction = nil
+	// not all code paths forward the list of properties that should be extracted - if nil is passed fall back
+	if properties != nil {
+		propertyPaths := make([][]string, len(properties))
+		for j := range properties {
+			propertyPaths[j] = []string{properties[j]}
+		}
+
+		props = &PropertyExtraction{
+			PropertyPaths: propertyPaths,
+		}
+	}
+
+	for _, id := range ids {
+		binary.LittleEndian.PutUint64(docIDBuf, id)
+		res, newBuf, err := bucket.GetBySecondaryWithBuffer(0, docIDBuf, lsmBuf)
+		if err != nil {
+			return nil, err
+		}
+
+		lsmBuf = newBuf // may have changed, e.g. because it was grown
+
+		// If there is a crash and WAL recovery, the inverted index may have objects that are not in the objects bucket.
+		// This is an issue that needs to be fixed, but for now we need to reduce the huge amount of log messages that
+		// are generated by this issue. Logging the first time we encounter a missing object in a query still resulted
+		// in a huge amount of log messages and it will happen on all queries, so we not log at all for now.
+		// The user has already been alerted about ppossible data loss when the WAL recovery happened.
+		// TODO: consider deleting these entries from the inverted index and alerting the user
+		if res == nil {
+			continue
+		}
+
+		unmarshalled, err := FromBinaryOptional(res, additional, props)
+		if err != nil {
+			return nil, errors.Wrapf(err, "unmarshal data object at position %d", i)
+		}
+
+		out[i] = unmarshalled
+		i++
+	}
+
+	return out[:i], nil
+}
+
+func (ko *Object) Class() schema.ClassName {
+	return schema.ClassName(ko.Object.Class)
+}
+
+func (ko *Object) SetDocID(id uint64) {
+	ko.DocID = id
+}
+
+func (ko *Object) GetDocID() uint64 {
+	return ko.DocID
+}
+
+func (ko *Object) CreationTimeUnix() int64 {
+	return ko.Object.CreationTimeUnix
+}
+
+func (ko *Object) ExplainScore() string {
+	props := ko.AdditionalProperties()
+	if props != nil {
+		iface := props["explainScore"]
+		if iface != nil {
+			return iface.(string)
+		}
+	}
+	return ""
+}
+
+func (ko *Object) ID() strfmt.UUID {
+	return ko.Object.ID
+}
+
+func (ko *Object) SetID(id strfmt.UUID) {
+	ko.Object.ID = id
+}
+
+func (ko *Object) SetClass(class string) {
+	ko.Object.Class = class
+}
+
+func (ko *Object) LastUpdateTimeUnix() int64 {
+	return ko.Object.LastUpdateTimeUnix
+}
+
+// AdditionalProperties groups all properties which are stored with the
+// object and not generated at runtime
+func (ko *Object) AdditionalProperties() models.AdditionalProperties {
+	return ko.Object.Additional
+}
+
+func (ko *Object) Properties() models.PropertySchema {
+	return ko.Object.Properties
+}
+
+func (ko *Object) PropertiesWithAdditional(
+	additional additional.Properties,
+) models.PropertySchema {
+	properties := ko.Properties()
+
+	if additional.RefMeta {
+		// nothing to remove
+		return properties
+	}
+
+	asMap, ok := properties.(map[string]interface{})
+	if !ok || asMap == nil {
+		return properties
+	}
+
+	for propName, value := range asMap {
+		asRefs, ok := value.(models.MultipleRef)
+		if !ok {
+			// not a ref, we can skip
+			continue
+		}
+
+		for i := range asRefs {
+			asRefs[i].Classification = nil
+		}
+
+		asMap[propName] = asRefs
+	}
+
+	return asMap
+}
+
+func (ko *Object) SetProperties(schema models.PropertySchema) {
+	ko.Object.Properties = schema
+}
+
+func (ko *Object) VectorWeights() models.VectorWeights {
+	return ko.Object.VectorWeights
+}
+
+func (ko *Object) SearchResult(additional additional.Properties, tenant string) *search.Result {
+	propertiesMap, ok := ko.PropertiesWithAdditional(additional).(map[string]interface{})
+	if !ok || propertiesMap == nil {
+		propertiesMap = map[string]interface{}{}
+	}
+	propertiesMap["id"] = ko.ID()
+	ko.SetProperties(propertiesMap)
+
+	additionalProperties := models.AdditionalProperties{}
+	if ko.AdditionalProperties() != nil {
+		if interpretation, ok := additional.ModuleParams["interpretation"]; ok {
+			if interpretationValue, ok := interpretation.(bool); ok && interpretationValue {
+				additionalProperties["interpretation"] = ko.AdditionalProperties()["interpretation"]
+			}
+		}
+		if additional.Classification {
+			additionalProperties["classification"] = ko.AdditionalProperties()["classification"]
+		}
+		if additional.Group {
+			additionalProperties["group"] = ko.AdditionalProperties()["group"]
+		}
+	}
+	if ko.ExplainScore() != "" {
+		additionalProperties["explainScore"] = ko.ExplainScore()
+	}
+
+	return &search.Result{
+		ID:        ko.ID(),
+		DocID:     &ko.DocID,
+		ClassName: ko.Class().String(),
+		Schema:    ko.Properties(),
+		Vector:    ko.Vector,
+		Vectors:   ko.asVectors(ko.Vectors, ko.MultiVectors),
+		Dims:      ko.VectorLen,
+		// VectorWeights: ko.VectorWeights(), // TODO: add vector weights
+		Created:              ko.CreationTimeUnix(),
+		Updated:              ko.LastUpdateTimeUnix(),
+		AdditionalProperties: additionalProperties,
+		// Score is filled in later
+		ExplainScore: ko.ExplainScore(),
+		IsConsistent: ko.IsConsistent,
+		Tenant:       tenant, // not part of the binary
+		// TODO: Beacon?
+	}
+}
+
+func (ko *Object) asVectors(vectors map[string][]float32, multiVectors map[string][][]float32) models.Vectors {
+	if (len(vectors) + len(multiVectors)) > 0 {
+		out := make(models.Vectors)
+		for targetVector, vector := range vectors {
+			out[targetVector] = vector
+		}
+		for targetVector, vector := range multiVectors {
+			out[targetVector] = vector
+		}
+		return out
+	}
+	return nil
+}
+
+func (ko *Object) GetVectors() models.Vectors {
+	return ko.asVectors(ko.Vectors, ko.MultiVectors)
+}
+
+func (ko *Object) SearchResultWithDist(addl additional.Properties, dist float32) search.Result {
+	res := ko.SearchResult(addl, "")
+	res.Dist = dist
+	res.Certainty = float32(additional.DistToCertainty(float64(dist)))
+	return *res
+}
+
+func (ko *Object) SearchResultWithScore(addl additional.Properties, score float32) search.Result {
+	res := ko.SearchResult(addl, "")
+	res.Score = score
+	return *res
+}
+
+func (ko *Object) SearchResultWithScoreAndTenant(addl additional.Properties, score float32, tenant string) search.Result {
+	res := ko.SearchResult(addl, tenant)
+	res.Score = score
+	return *res
+}
+
+func (ko *Object) Valid() bool {
+	return ko.ID() != "" &&
+		ko.Class().String() != ""
+}
+
+// IterateThroughVectorDimensions iterates through all vectors present on the Object and invokes
+// the callback with target name and dimensions of the vector.
+func (ko *Object) IterateThroughVectorDimensions(f func(targetVector string, dims int) error) error {
+	if len(ko.Vector) > 0 {
+		if err := f("", len(ko.Vector)); err != nil {
+			return err
+		}
+	}
+
+	for targetVector, vector := range ko.Vectors {
+		if err := f(targetVector, len(vector)); err != nil {
+			return err
+		}
+	}
+
+	for targetVector, vectors := range ko.MultiVectors {
+		var dims int
+		for _, vector := range vectors {
+			dims += len(vector)
+		}
+		if err := f(targetVector, dims); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func SearchResults(in []*Object, additional additional.Properties, tenant string) search.Results {
+	out := make(search.Results, len(in))
+
+	for i, elem := range in {
+		out[i] = *(elem.SearchResult(additional, tenant))
+	}
+
+	return out
+}
+
+func SearchResultsWithScore(in []*Object, scores []float32, additional additional.Properties, tenant string) search.Results {
+	out := make(search.Results, len(in))
+
+	for i, elem := range in {
+		score := float32(0.0)
+		if len(scores) > i {
+			score = scores[i]
+		}
+		out[i] = elem.SearchResultWithScoreAndTenant(additional, score, tenant)
+	}
+
+	return out
+}
+
+func SearchResultsWithDists(in []*Object, addl additional.Properties,
+	dists []float32,
+) search.Results {
+	out := make(search.Results, len(in))
+
+	for i, elem := range in {
+		out[i] = elem.SearchResultWithDist(addl, dists[i])
+	}
+
+	return out
+}
+
+func DocIDFromBinary(in []byte) (uint64, error) {
+	if len(in) < 9 {
+		return 0, errors.Errorf("binary data too short")
+	}
+	// first by is kind, then 8 bytes for the docID
+	return binary.LittleEndian.Uint64(in[1:9]), nil
+}
+
+func DocIDAndTimeFromBinary(in []byte) (docID uint64, updateTime int64, err error) {
+	r := bytes.NewReader(in)
+
+	var version uint8
+
+	le := binary.LittleEndian
+
+	if err := binary.Read(r, le, &version); err != nil {
+		return 0, 0, err
+	}
+
+	if version != 1 {
+		return 0, 0, errors.Errorf("unsupported binary marshaller version %d", version)
+	}
+
+	err = binary.Read(r, le, &docID)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	var buf [1 + 16 + 8 + 8]byte // kind uuid createtime updatetime
+
+	_, err = io.ReadFull(r, buf[:])
+	if err != nil {
+		return 0, 0, err
+	}
+
+	updateTime = int64(binary.LittleEndian.Uint64(buf[1+16+8:]))
+
+	return docID, updateTime, nil
+}
+
+// MarshalBinary creates the binary representation of a kind object. Regardless
+// of the marshaller version the first byte is a uint8 indicating the version
+// followed by the payload which depends on the specific version
+//
+// Version 1
+// No. of B      | Type                     | Content
+// --------------------------------------------------------------
+// 1             | uint8                    | MarshallerVersion = 1
+// 8             | uint64                   | index id, keep early so id-only lookups are maximum efficient
+// 1             | uint8                    | kind, 0=action, 1=thing - deprecated
+// 16            | uint128                  | uuid
+// 8             | int64                    | create time
+// 8             | int64                    | update time
+// 2             | uint16                   | VectorLength
+// n*4           | []float32                | vector of length n
+// 2             | uint16                   | length of class name
+// n             | []byte                   | className
+// 4             | uint32                   | length of schema json
+// n             | []byte                   | schema as json
+// 4             | uint32                   | length of meta json
+// n             | []byte                   | meta as json
+// 4             | uint32                   | length of vectorweights json
+// n             | []byte                   | vectorweights as json
+// 4             | uint32                   | length of packed target vectors offsets (in bytes)
+// n             | []byte                   | packed target vectors offsets map { name : offset_in_bytes }
+// 4             | uint32                   | length of target vectors segment (in bytes)
+// n             | uint16+[]byte            | target vectors segment: sequence of vec_length + vec (uint16 + []byte), (uint16 + []byte) ...
+// 4             | uint32                   | length of packed multivector offsets (in bytes)
+// n             | []byte                   | packed multivector offsets map { name : offset_in_bytes }
+// 4             | uint32                   | length of multivectors segment (in bytes)
+// 4 + (2 + n*4) | uint32 + (uint16+[]byte) | multivectors segment: num vecs + (vec length + vec floats), ...
+// TODO vec lengths immediately following num vecs so you can jump straight to specific vec?
+
+const (
+	maxVectorLength               int = math.MaxUint16
+	maxClassNameLength            int = math.MaxUint16
+	maxSchemaLength               int = math.MaxUint32
+	maxMetaLength                 int = math.MaxUint32
+	maxVectorWeightsLength        int = math.MaxUint32
+	maxTargetVectorsSegmentLength int = math.MaxUint32
+	maxTargetVectorsOffsetsLength int = math.MaxUint32
+	maxMultiVectorsSegmentLength  int = math.MaxUint32
+	maxMultiVectorsOffsetsLength  int = math.MaxUint32
+)
+
+func (ko *Object) MarshalBinary() ([]byte, error) {
+	if ko.MarshallerVersion != 1 {
+		return nil, errors.Errorf("unsupported marshaller version %d", ko.MarshallerVersion)
+	}
+
+	kindByte := uint8(0)
+	// Deprecated Kind field
+	kindByte = 1
+
+	idParsed, err := uuid.Parse(ko.ID().String())
+	if err != nil {
+		return nil, err
+	}
+	idBytes, err := idParsed.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ko.Vector) > maxVectorLength {
+		return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "vector", len(ko.Vector), maxVectorLength)
+	}
+	vectorLength := uint32(len(ko.Vector))
+
+	className := []byte(ko.Class())
+	if len(className) > maxClassNameLength {
+		return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "className", len(className), maxClassNameLength)
+	}
+	classNameLength := uint32(len(className))
+
+	schema, err := json.Marshal(ko.Properties())
+	if err != nil {
+		return nil, err
+	}
+	if len(schema) > maxSchemaLength {
+		return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "schema", len(schema), maxSchemaLength)
+	}
+	schemaLength := uint32(len(schema))
+
+	meta, err := json.Marshal(ko.AdditionalProperties())
+	if err != nil {
+		return nil, err
+	}
+	if len(meta) > maxMetaLength {
+		return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "meta", len(meta), maxMetaLength)
+	}
+	metaLength := uint32(len(meta))
+
+	vectorWeights, err := json.Marshal(ko.VectorWeights())
+	if err != nil {
+		return nil, err
+	}
+	if len(vectorWeights) > maxVectorWeightsLength {
+		return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "vectorWeights", len(vectorWeights), maxVectorWeightsLength)
+	}
+	vectorWeightsLength := uint32(len(vectorWeights))
+
+	var targetVectorsOffsets []byte
+	var targetVectorsOffsetsLength uint32
+	var targetVectorsSegmentLength int
+
+	targetVectorsOffsetOrder := make([]string, 0, len(ko.Vectors))
+	if len(ko.Vectors) > 0 {
+		offsetsMap := map[string]uint32{}
+		for name, vec := range ko.Vectors {
+			if len(vec) > maxVectorLength {
+				return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "vector", len(vec), maxVectorLength)
+			}
+
+			offsetsMap[name] = uint32(targetVectorsSegmentLength)
+			targetVectorsSegmentLength += 2 + 4*len(vec) // 2 for vec length + vec bytes
+
+			if targetVectorsSegmentLength > maxTargetVectorsSegmentLength {
+				return nil,
+					fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)",
+						"targetVectorsSegmentLength", targetVectorsSegmentLength, maxTargetVectorsSegmentLength)
+			}
+
+			targetVectorsOffsetOrder = append(targetVectorsOffsetOrder, name)
+		}
+
+		targetVectorsOffsets, err = msgpack.Marshal(offsetsMap)
+		if err != nil {
+			return nil, fmt.Errorf("could not marshal target vectors offsets: %w", err)
+		}
+		if len(targetVectorsOffsets) > maxTargetVectorsOffsetsLength {
+			return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "targetVectorsOffsets", len(targetVectorsOffsets), maxTargetVectorsOffsetsLength)
+		}
+		targetVectorsOffsetsLength = uint32(len(targetVectorsOffsets))
+	}
+
+	var multiVectorsOffsets []byte
+	var multiVectorsOffsetsLength uint32
+	var multiVectorsSegmentLength int
+
+	multiVectorsOffsetOrder := make([]string, 0, len(ko.MultiVectors))
+	if len(ko.MultiVectors) > 0 {
+		offsetsMap := map[string]uint32{}
+		for name, vecs := range ko.MultiVectors {
+			offsetsMap[name] = uint32(multiVectorsSegmentLength)
+			// 4 bytes for number of vectors
+			multiVectorsSegmentLength += 4
+			for _, vec := range vecs {
+				if len(vec) > maxVectorLength {
+					return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "vector", len(vec), maxVectorLength)
+				}
+				// 2 bytes for vec length and 4 bytes per float32
+				multiVectorsSegmentLength += 2 + 4*len(vec)
+
+				if multiVectorsSegmentLength > maxMultiVectorsSegmentLength {
+					return nil,
+						fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)",
+							"multiVectorsSegmentLength", multiVectorsSegmentLength, maxMultiVectorsSegmentLength)
+				}
+			}
+			multiVectorsOffsetOrder = append(multiVectorsOffsetOrder, name)
+		}
+
+		multiVectorsOffsets, err = msgpack.Marshal(offsetsMap)
+		if err != nil {
+			return nil, fmt.Errorf("could not marshal multi vectors offsets: %w", err)
+		}
+		if len(multiVectorsOffsets) > maxMultiVectorsOffsetsLength {
+			return nil, fmt.Errorf("could not marshal '%s' max length exceeded (%d/%d)", "multiVectorsOffsets", len(multiVectorsOffsets), maxMultiVectorsOffsetsLength)
+		}
+		multiVectorsOffsetsLength = uint32(len(multiVectorsOffsets))
+	}
+
+	totalBufferLength := 1 + 8 + 1 + 16 + 8 + 8 +
+		2 + vectorLength*4 +
+		2 + classNameLength +
+		4 + schemaLength +
+		4 + metaLength +
+		4 + vectorWeightsLength +
+		4 + targetVectorsOffsetsLength +
+		4 + uint32(targetVectorsSegmentLength) +
+		4 + multiVectorsOffsetsLength +
+		4 + uint32(multiVectorsSegmentLength)
+
+	byteBuffer := make([]byte, totalBufferLength)
+	rw := byteops.NewReadWriter(byteBuffer)
+	rw.WriteByte(ko.MarshallerVersion)
+	rw.WriteUint64(ko.DocID)
+	rw.WriteByte(kindByte)
+
+	rw.CopyBytesToBuffer(idBytes)
+
+	rw.WriteUint64(uint64(ko.CreationTimeUnix()))
+	rw.WriteUint64(uint64(ko.LastUpdateTimeUnix()))
+	rw.WriteUint16(uint16(vectorLength))
+
+	for j := uint32(0); j < vectorLength; j++ {
+		rw.WriteUint32(math.Float32bits(ko.Vector[j]))
+	}
+
+	rw.WriteUint16(uint16(classNameLength))
+	err = rw.CopyBytesToBuffer(className)
+	if err != nil {
+		return byteBuffer, errors.Wrap(err, "Could not copy className")
+	}
+
+	rw.WriteUint32(schemaLength)
+	err = rw.CopyBytesToBuffer(schema)
+	if err != nil {
+		return byteBuffer, errors.Wrap(err, "Could not copy schema")
+	}
+
+	rw.WriteUint32(metaLength)
+	err = rw.CopyBytesToBuffer(meta)
+	if err != nil {
+		return byteBuffer, errors.Wrap(err, "Could not copy meta")
+	}
+
+	rw.WriteUint32(vectorWeightsLength)
+	err = rw.CopyBytesToBuffer(vectorWeights)
+	if err != nil {
+		return byteBuffer, errors.Wrap(err, "Could not copy vectorWeights")
+	}
+
+	rw.WriteUint32(targetVectorsOffsetsLength)
+	if targetVectorsOffsetsLength > 0 {
+		err = rw.CopyBytesToBuffer(targetVectorsOffsets)
+		if err != nil {
+			return byteBuffer, errors.Wrap(err, "Could not copy targetVectorsOffsets")
+		}
+	}
+
+	rw.WriteUint32(uint32(targetVectorsSegmentLength))
+	for _, name := range targetVectorsOffsetOrder {
+		vec := ko.Vectors[name]
+		vecLen := len(vec)
+
+		rw.WriteUint16(uint16(vecLen))
+		for j := 0; j < vecLen; j++ {
+			rw.WriteUint32(math.Float32bits(vec[j]))
+		}
+	}
+
+	rw.WriteUint32(multiVectorsOffsetsLength)
+	if multiVectorsOffsetsLength > 0 {
+		err = rw.CopyBytesToBuffer(multiVectorsOffsets)
+		if err != nil {
+			return byteBuffer, errors.Wrap(err, "Could not copy multiVectorsOffsets")
+		}
+	}
+
+	rw.WriteUint32(uint32(multiVectorsSegmentLength))
+	for _, name := range multiVectorsOffsetOrder {
+		vecs := ko.MultiVectors[name]
+		rw.WriteUint32(uint32(len(vecs)))
+		for _, vec := range vecs {
+			vecLen := len(vec)
+			rw.WriteUint16(uint16(vecLen))
+			for j := 0; j < vecLen; j++ {
+				rw.WriteUint32(math.Float32bits(vec[j]))
+			}
+		}
+	}
+
+	return byteBuffer, nil
+}
+
+// UnmarshalPropertiesFromObject accepts marshaled object as data and populates resultProperties map with the properties specified by propertyPaths.
+//
+// Check MarshalBinary for the order of elements in the input array
+func UnmarshalPropertiesFromObject(data []byte, resultProperties map[string]interface{}, propertyPaths [][]string) error {
+	if data[0] != uint8(1) {
+		return errors.Errorf("unsupported binary marshaller version %d", data[0])
+	}
+
+	// clear out old values in case an object misses values. This should NOT shrink the capacity of the map, eg there
+	// are no allocations when adding the resultProperties of the next object again
+	clear(resultProperties)
+
+	startPos := uint64(1 + 8 + 1 + 16 + 8 + 8) // elements at the start
+	rw := byteops.NewReadWriterWithOps(data, byteops.WithPosition(startPos))
+	// get the length of the vector, each element is a float32 (4 bytes)
+	vectorLength := uint64(rw.ReadUint16())
+	rw.MoveBufferPositionForward(vectorLength * 4)
+	classnameLength := uint64(rw.ReadUint16())
+	rw.MoveBufferPositionForward(classnameLength)
+	propertyLength := uint64(rw.ReadUint32())
+
+	return UnmarshalProperties(rw.Buffer[rw.Position:rw.Position+propertyLength], resultProperties, propertyPaths)
+}
+
+// UnmarshalProperties accepts serialized properties as data and populates resultProperties map with the properties specified by propertyPaths.
+func UnmarshalProperties(data []byte, properties map[string]interface{}, propertyPaths [][]string) error {
+	var returnError error
+	jsonparser.EachKey(data, func(idx int, value []byte, dataType jsonparser.ValueType, err error) {
+		propertyName := propertyPaths[idx][len(propertyPaths[idx])-1]
+
+		switch dataType {
+		case jsonparser.Number, jsonparser.String, jsonparser.Boolean:
+			val, err := parseValues(dataType, value)
+			if err != nil {
+				returnError = err
+			}
+			properties[propertyName] = val
+		case jsonparser.Array: // can be a beacon or an actual array
+			arrayEntries := value[1 : len(value)-1] // without leading and trailing []
+			// this checks if refs are present - the return points to the underlying memory, dont use without copying
+			_, errBeacon := jsonparser.GetUnsafeString(arrayEntries, "beacon")
+			if errBeacon == nil {
+				// there can be more than one
+				var beacons []interface{}
+				handler := func(beaconByte []byte, dataType jsonparser.ValueType, offset int, err error) {
+					beaconVal, err2 := jsonparser.GetString(beaconByte, "beacon") // this points to the underlying memory
+					returnError = err2
+					beacons = append(beacons, map[string]interface{}{"beacon": beaconVal})
+				}
+				_, returnError = jsonparser.ArrayEach(value, handler)
+				properties[propertyName] = beacons
+			} else {
+				// check how many entries there are in the array by counting the ",". This allows us to allocate an
+				// array with the right size without extending it with every append.
+				// The size can be too large for string arrays, when they contain "," as part of their content.
+				entryCount := 0
+				for _, b := range arrayEntries {
+					if b == uint8(44) { // ',' as byte
+						entryCount++
+					}
+				}
+
+				array := make([]interface{}, 0, entryCount)
+				_, err = jsonparser.ArrayEach(value, func(innerValue []byte, innerDataType jsonparser.ValueType, offset int, innerErr error) {
+					var val interface{}
+
+					switch innerDataType {
+					case jsonparser.Number, jsonparser.String, jsonparser.Boolean:
+						val, err = parseValues(innerDataType, innerValue)
+						if err != nil {
+							returnError = err
+							return
+						}
+					case jsonparser.Object:
+						nestedProps := map[string]interface{}{}
+						err := json.Unmarshal(innerValue, &nestedProps)
+						if err != nil {
+							returnError = err
+							return
+						}
+						val = nestedProps
+					default:
+						returnError = fmt.Errorf("unknown data type ArrayEach %v", innerDataType)
+						return
+					}
+					array = append(array, val)
+				})
+				if err != nil {
+					returnError = err
+				}
+				properties[propertyName] = array
+
+			}
+		case jsonparser.Object:
+			// nested objects and geo-props and phonenumbers.
+			//
+			// we do not have the schema for nested object and cannot use the efficient jsonparser for them
+			//  (we could for phonenumbers and geo-props but they are not worth the effort)
+			// however this part is only called if
+			// - one of the datatypes is present
+			// - AND the user requests them
+			// => the performance impact is minimal
+			nestedProps := map[string]interface{}{}
+			err := json.Unmarshal(value, &nestedProps)
+			if err != nil {
+				returnError = err
+			}
+			properties[propertyName] = nestedProps
+		default:
+			returnError = fmt.Errorf("unknown data type %v", dataType)
+		}
+	}, propertyPaths...)
+
+	return returnError
+}
+
+func parseValues(dt jsonparser.ValueType, value []byte) (interface{}, error) {
+	switch dt {
+	case jsonparser.Number:
+		return jsonparser.ParseFloat(value)
+	case jsonparser.String:
+		return jsonparser.ParseString(value)
+	case jsonparser.Boolean:
+		return jsonparser.ParseBoolean(value)
+	default:
+		panic("Unknown data type") // returning an error would be better
+	}
+}
+
+// UnmarshalBinary is the versioned way to unmarshal a kind object from binary,
+// see MarshalBinary for the exact contents of each version
+func (ko *Object) UnmarshalBinary(data []byte) error {
+	version := data[0]
+	if version != 1 {
+		return errors.Errorf("unsupported binary marshaller version %d", version)
+	}
+	ko.MarshallerVersion = version
+
+	rw := byteops.NewReadWriterWithOps(data, byteops.WithPosition(1))
+	ko.DocID = rw.ReadUint64()
+	rw.MoveBufferPositionForward(1) // kind-byte
+
+	uuidParsed, err := uuid.FromBytes(data[rw.Position : rw.Position+16])
+	if err != nil {
+		return err
+	}
+	rw.MoveBufferPositionForward(16)
+
+	createTime := int64(rw.ReadUint64())
+	updateTime := int64(rw.ReadUint64())
+
+	vectorLength := rw.ReadUint16()
+	ko.VectorLen = int(vectorLength)
+	ko.Vector = make([]float32, vectorLength)
+	for j := 0; j < int(vectorLength); j++ {
+		ko.Vector[j] = math.Float32frombits(rw.ReadUint32())
+	}
+
+	classNameLength := uint64(rw.ReadUint16())
+	className, err := rw.CopyBytesFromBuffer(classNameLength, nil)
+	if err != nil {
+		return errors.Wrap(err, "Could not copy class name")
+	}
+
+	schemaLength := uint64(rw.ReadUint32())
+	schema, err := rw.CopyBytesFromBuffer(schemaLength, nil)
+	if err != nil {
+		return errors.Wrap(err, "Could not copy schema")
+	}
+
+	metaLength := uint64(rw.ReadUint32())
+	meta, err := rw.CopyBytesFromBuffer(metaLength, nil)
+	if err != nil {
+		return errors.Wrap(err, "Could not copy meta")
+	}
+
+	vectorWeightsLength := uint64(rw.ReadUint32())
+	vectorWeights, err := rw.CopyBytesFromBuffer(vectorWeightsLength, nil)
+	if err != nil {
+		return errors.Wrap(err, "Could not copy vectorWeights")
+	}
+
+	vectors, err := unmarshalTargetVectors(&rw)
+	if err != nil {
+		return err
+	}
+	ko.Vectors = vectors
+
+	multiVectors, err := unmarshalMultiVectors(&rw, nil)
+	if err != nil {
+		return err
+	}
+	ko.MultiVectors = multiVectors
+
+	return ko.parseObject(
+		strfmt.UUID(uuidParsed.String()),
+		createTime,
+		updateTime,
+		string(className),
+		schema,
+		meta,
+		vectorWeights, nil, 0,
+	)
+}
+
+func unmarshalTargetVectors(rw *byteops.ReadWriter) (map[string][]float32, error) {
+	// This check prevents from panic when somebody is upgrading from version that
+	// didn't have multiple target vector support. This check is needed bc with named vectors
+	// feature storage object can have vectors data appended at the end of the file
+	if rw.Position < uint64(len(rw.Buffer)) {
+		targetVectorsOffsets := rw.ReadBytesFromBufferWithUint32LengthIndicator()
+		targetVectorsSegmentLength := rw.ReadUint32()
+		pos := rw.Position
+
+		if len(targetVectorsOffsets) > 0 {
+			var tvOffsets map[string]uint32
+			if err := msgpack.Unmarshal(targetVectorsOffsets, &tvOffsets); err != nil {
+				return nil, fmt.Errorf("could not unmarshal target vectors offset: %w", err)
+			}
+
+			targetVectors := map[string][]float32{}
+			for name, offset := range tvOffsets {
+				rw.MoveBufferToAbsolutePosition(pos + uint64(offset))
+				vecLen := rw.ReadUint16()
+				vec := make([]float32, vecLen)
+				for j := uint16(0); j < vecLen; j++ {
+					vec[j] = math.Float32frombits(rw.ReadUint32())
+				}
+				targetVectors[name] = vec
+			}
+
+			rw.MoveBufferToAbsolutePosition(pos + uint64(targetVectorsSegmentLength))
+			return targetVectors, nil
+		}
+	}
+	return nil, nil
+}
+
+// unmarshalMultiVectors unmarshals the multi vectors from the buffer. If onlyUnmarshalNames is set and non-empty,
+// then only the multivectors which names specified as the map's keys will be unmarshaled.
+func unmarshalMultiVectors(
+	rw *byteops.ReadWriter,
+	onlyUnmarshalNames map[string]interface{},
+) (map[string][][]float32, error) {
+	// This check prevents from panic when somebody is upgrading from version that
+	// didn't have multi vector support. This check is needed bc with the multi vectors
+	// feature the storage object can have vectors data appended at the end of the file
+	if rw.Position < uint64(len(rw.Buffer)) {
+		multiVectorsOffsets := rw.ReadBytesFromBufferWithUint32LengthIndicator()
+		multiVectorsSegmentLength := rw.ReadUint32()
+		pos := rw.Position
+
+		if len(multiVectorsOffsets) > 0 {
+			var mvOffsets map[string]uint32
+			if err := msgpack.Unmarshal(multiVectorsOffsets, &mvOffsets); err != nil {
+				return nil, fmt.Errorf("could not unmarshal multi vectors offset: %w", err)
+			}
+
+			// NOTE if you sort mvOffsets by offset, you may be able to speed this up via
+			// sequential reads, haven't tried this yet
+			multiVectors := map[string][][]float32{}
+			for name, offset := range mvOffsets {
+				// if onlyUnmarshalNames is not nil and non-empty, only unmarshal the vectors
+				// for the names in the map
+				if len(onlyUnmarshalNames) > 0 {
+					if _, ok := onlyUnmarshalNames[name]; !ok {
+						continue
+					}
+				}
+				rw.MoveBufferToAbsolutePosition(pos + uint64(offset))
+				numVecs := rw.ReadUint32()
+				vecs := make([][]float32, 0)
+				for i := 0; i < int(numVecs); i++ {
+					vecLen := rw.ReadUint16()
+					vec := make([]float32, vecLen)
+					for j := uint16(0); j < vecLen; j++ {
+						vec[j] = math.Float32frombits(rw.ReadUint32())
+					}
+					vecs = append(vecs, vec)
+				}
+				multiVectors[name] = vecs
+			}
+
+			rw.MoveBufferToAbsolutePosition(pos + uint64(multiVectorsSegmentLength))
+			return multiVectors, nil
+		}
+	}
+	return nil, nil
+}
+
+func VectorFromBinary(in []byte, buffer []float32, targetVector string) ([]float32, error) {
+	if len(in) == 0 {
+		return nil, nil
+	}
+
+	version := in[0]
+	if version != 1 {
+		return nil, errors.Errorf("unsupported marshaller version %d", version)
+	}
+
+	if targetVector != "" {
+		startPos := uint64(1 + 8 + 1 + 16 + 8 + 8) // elements at the start
+		rw := byteops.NewReadWriterWithOps(in, byteops.WithPosition(startPos))
+
+		vectorLength := uint64(rw.ReadUint16())
+		rw.MoveBufferPositionForward(vectorLength * 4)
+
+		classnameLength := uint64(rw.ReadUint16())
+		rw.MoveBufferPositionForward(classnameLength)
+
+		schemaLength := uint64(rw.ReadUint32())
+		rw.MoveBufferPositionForward(schemaLength)
+
+		metaLength := uint64(rw.ReadUint32())
+		rw.MoveBufferPositionForward(metaLength)
+
+		vectorWeightsLength := uint64(rw.ReadUint32())
+		rw.MoveBufferPositionForward(vectorWeightsLength)
+
+		targetVectors, err := unmarshalTargetVectors(&rw)
+		if err != nil {
+			return nil, errors.Errorf("unable to unmarshal vector for target vector: %s", targetVector)
+		}
+		vector, ok := targetVectors[targetVector]
+		if !ok {
+			return nil, errors.Errorf("vector not found for target vector: %s", targetVector)
+		}
+		return vector, nil
+	}
+
+	// since we know the version and know that the blob is not len(0), we can
+	// assume that we can directly access the vector length field. The only
+	// situation where this is not accessible would be on corrupted data - where
+	// it would be acceptable to panic
+	vecLen := binary.LittleEndian.Uint16(in[42:44])
+
+	var out []float32
+	if cap(buffer) >= int(vecLen) {
+		out = buffer[:vecLen]
+	} else {
+		out = make([]float32, vecLen)
+	}
+	vecStart := 44
+	vecEnd := vecStart + int(vecLen*4)
+
+	i := 0
+	for start := vecStart; start < vecEnd; start += 4 {
+		asUint := binary.LittleEndian.Uint32(in[start : start+4])
+		out[i] = math.Float32frombits(asUint)
+		i++
+	}
+
+	return out, nil
+}
+
+func incrementPos(in []byte, pos int, size int) int {
+	b := in[pos : pos+size]
+	if size == 2 {
+		length := binary.LittleEndian.Uint16(b)
+		pos += size + int(length)
+	} else if size == 4 {
+		length := binary.LittleEndian.Uint32(b)
+		pos += size + int(length)
+		return pos
+	} else if size == 8 {
+		length := binary.LittleEndian.Uint64(b)
+		pos += size + int(length)
+	}
+	return pos
+}
+
+func MultiVectorFromBinary(in []byte, buffer []float32, targetVector string) ([][]float32, error) {
+	if len(in) == 0 {
+		return nil, nil
+	}
+
+	version := in[0]
+	if version != 1 {
+		return nil, errors.Errorf("unsupported marshaller version %d", version)
+	}
+
+	// since we know the version and know that the blob is not len(0), we can
+	// assume that we can directly access the vector length field. The only
+	// situation where this is not accessible would be on corrupted data - where
+	// it would be acceptable to panic
+	vecLen := binary.LittleEndian.Uint16(in[42:44])
+
+	var out []float32
+	if cap(buffer) >= int(vecLen) {
+		out = buffer[:vecLen]
+	} else {
+		out = make([]float32, vecLen)
+	}
+	vecStart := 44
+	vecEnd := vecStart + int(vecLen*4)
+
+	i := 0
+	for start := vecStart; start < vecEnd; start += 4 {
+		asUint := binary.LittleEndian.Uint32(in[start : start+4])
+		out[i] = math.Float32frombits(asUint)
+		i++
+	}
+
+	pos := vecEnd
+
+	pos = incrementPos(in, pos, 2) // classNameLength
+	pos = incrementPos(in, pos, 4) // schemaLength
+	pos = incrementPos(in, pos, 4) // metaLength
+	pos = incrementPos(in, pos, 4) // vectorWeightsLength
+	pos = incrementPos(in, pos, 4) // bufLen
+	pos = incrementPos(in, pos, 4) // targetVectorsSegmentLength
+
+	// multivector
+	var multiVectors map[string][][]float32
+
+	if len(in) > pos {
+		rw := byteops.NewReadWriterWithOps(in, byteops.WithPosition(uint64(pos)))
+		mv, err := unmarshalMultiVectors(&rw, map[string]interface{}{targetVector: nil})
+		if err != nil {
+			return nil, errors.Errorf("unable to unmarshal multivector for target vector: %s", targetVector)
+		}
+		multiVectors = mv
+	}
+
+	mvout, ok := multiVectors[targetVector]
+	if !ok {
+		return nil, errors.Errorf("vector not found for target vector: %s", targetVector)
+	}
+	return mvout, nil
+}
+
+func (ko *Object) parseObject(uuid strfmt.UUID, create, update int64, className string,
+	propsB []byte, additionalB []byte, vectorWeightsB []byte, properties *PropertyExtraction, propLength uint32,
+) error {
+	var returnProps map[string]interface{}
+	if properties == nil || propLength == 0 {
+		if err := json.Unmarshal(propsB, &returnProps); err != nil {
+			return err
+		}
+	} else if len(propsB) >= int(propLength) {
+		// the properties are not read in all cases, skip if not needed
+		returnProps = make(map[string]interface{}, len(properties.PropertyPaths))
+		if err := UnmarshalProperties(propsB[:propLength], returnProps, properties.PropertyPaths); err != nil {
+			return err
+		}
+	}
+
+	if err := enrichSchemaTypes(returnProps, false); err != nil {
+		return errors.Wrap(err, "enrich schema datatypes")
+	}
+
+	var additionalProperties models.AdditionalProperties
+	if len(additionalB) > 0 {
+		if err := json.Unmarshal(additionalB, &additionalProperties); err != nil {
+			return err
+		}
+
+		if prop, ok := additionalProperties["classification"]; ok {
+			if classificationMap, ok := prop.(map[string]interface{}); ok {
+				marshalled, err := json.Marshal(classificationMap)
+				if err != nil {
+					return err
+				}
+				var classification additional.Classification
+				err = json.Unmarshal(marshalled, &classification)
+				if err != nil {
+					return err
+				}
+				additionalProperties["classification"] = &classification
+			}
+		}
+
+		if prop, ok := additionalProperties["group"]; ok {
+			if groupMap, ok := prop.(map[string]interface{}); ok {
+				marshalled, err := json.Marshal(groupMap)
+				if err != nil {
+					return err
+				}
+				var group additional.Group
+				err = json.Unmarshal(marshalled, &group)
+				if err != nil {
+					return err
+				}
+
+				for i, hit := range group.Hits {
+					if groupHitAdditionalMap, ok := hit["_additional"].(map[string]interface{}); ok {
+						marshalled, err := json.Marshal(groupHitAdditionalMap)
+						if err != nil {
+							return err
+						}
+						var groupHitsAdditional additional.GroupHitAdditional
+						err = json.Unmarshal(marshalled, &groupHitsAdditional)
+						if err != nil {
+							return err
+						}
+						group.Hits[i]["_additional"] = &groupHitsAdditional
+					}
+				}
+
+				additionalProperties["group"] = &group
+			}
+		}
+	}
+
+	var vectorWeights interface{}
+	if err := json.Unmarshal(vectorWeightsB, &vectorWeights); err != nil {
+		return err
+	}
+
+	ko.Object = models.Object{
+		Class:              className,
+		CreationTimeUnix:   create,
+		LastUpdateTimeUnix: update,
+		ID:                 uuid,
+		Properties:         returnProps,
+		VectorWeights:      vectorWeights,
+		Additional:         additionalProperties,
+	}
+
+	return nil
+}
+
+// DeepCopyDangerous creates a deep copy of the underlying Object
+// WARNING: This was purpose built for the batch ref usecase and only covers
+// the situations that are required there. This means that cases which aren't
+// reflected in that usecase may still contain references. Thus the suffix
+// "Dangerous". If needed, make sure everything is copied and remove the
+// suffix.
+func (ko *Object) DeepCopyDangerous() *Object {
+	o := &Object{
+		MarshallerVersion: ko.MarshallerVersion,
+		DocID:             ko.DocID,
+		Object:            deepCopyObject(ko.Object),
+		Vector:            deepCopyVector(ko.Vector),
+		Vectors:           deepCopyVectorsMap(ko.Vectors),
+		MultiVectors:      deepCopyMultiVectorsMap(ko.MultiVectors),
+	}
+
+	return o
+}
+
+func AddOwnership(objs []*Object, node, shard string) {
+	for i := range objs {
+		objs[i].BelongsToNode = node
+		objs[i].BelongsToShard = shard
+	}
+}
+
+func deepCopyVector(orig []float32) []float32 {
+	out := make([]float32, len(orig))
+	copy(out, orig)
+	return out
+}
+
+func deepCopyMultiVector(orig [][]float32) [][]float32 {
+	out := make([][]float32, len(orig))
+	copy(out, orig)
+	return out
+}
+
+func deepCopyVectors(orig models.Vectors) models.Vectors {
+	out := make(models.Vectors, len(orig))
+	for key, vec := range orig {
+		switch v := any(vec).(type) {
+		case []float32:
+			out[key] = deepCopyVector(v)
+		case [][]float32:
+			out[key] = deepCopyMultiVector(v)
+		default:
+			// do nothing
+		}
+	}
+	return out
+}
+
+func deepCopyVectorsMap(orig map[string][]float32) map[string][]float32 {
+	out := make(map[string][]float32, len(orig))
+	for key, vec := range orig {
+		switch v := any(vec).(type) {
+		case []float32:
+			out[key] = deepCopyVector(v)
+		default:
+			// do nothing
+		}
+	}
+	return out
+}
+
+func deepCopyMultiVectorsMap(orig map[string][][]float32) map[string][][]float32 {
+	out := make(map[string][][]float32, len(orig))
+	for key, vec := range orig {
+		switch v := any(vec).(type) {
+		case [][]float32:
+			out[key] = deepCopyMultiVector(v)
+		default:
+			// do nothing
+		}
+	}
+	return out
+}
+
+func deepCopyObject(orig models.Object) models.Object {
+	return models.Object{
+		Class:              orig.Class,
+		ID:                 orig.ID,
+		CreationTimeUnix:   orig.CreationTimeUnix,
+		LastUpdateTimeUnix: orig.LastUpdateTimeUnix,
+		Vector:             deepCopyVector(orig.Vector),
+		VectorWeights:      orig.VectorWeights,
+		Additional:         orig.Additional, // WARNING: not a deep copy!!
+		Properties:         deepCopyProperties(orig.Properties),
+		Vectors:            deepCopyVectors(orig.Vectors),
+	}
+}
+
+func deepCopyProperties(orig models.PropertySchema) models.PropertySchema {
+	if orig == nil {
+		return nil
+	}
+
+	asMap, ok := orig.(map[string]interface{})
+	if !ok {
+		// not a map, don't know what to do with this
+		return nil
+	}
+
+	out := map[string]interface{}{}
+
+	for key, value := range asMap {
+		if mref, ok := value.(models.MultipleRef); ok {
+			out[key] = deepCopyMRef(mref)
+			continue
+		}
+
+		// Note: This is not a true deep copy, value could still be a pointer type,
+		// such as *models.GeoCoordinates, thus leading to passing a reference
+		// instead of actually making a copy. However, for the purposes we need
+		// this method for this is acceptable based on our current knowledge
+		out[key] = value
+	}
+
+	return out
+}
+
+func deepCopyMRef(orig models.MultipleRef) models.MultipleRef {
+	if orig == nil {
+		return nil
+	}
+
+	out := make(models.MultipleRef, len(orig))
+	for i, ref := range orig {
+		// models.SingleRef contains only pass-by-value props, so a simple deref as
+		// the struct creates a copy
+		copiedRef := *ref
+		out[i] = &copiedRef
+	}
+
+	return out
+}

platform/dbops/binaries/weaviate-src/entities/storobj/storage_object_test.go

@@ -0,0 +1,1629 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package storobj
+
+import (
+	cryptorand "crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"math/rand"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/weaviate/weaviate/usecases/byteops"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/additional"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func TestStorageObjectMarshalling(t *testing.T) {
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"name": "MyName",
+				"foo":  float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector1": {1, 2, 3},
+			"vector2": {4, 5, 6},
+		},
+		nil,
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	after, err := FromBinary(asBinary)
+	require.Nil(t, err)
+
+	t.Run("compare", func(t *testing.T) {
+		assert.Equal(t, before, after)
+	})
+
+	t.Run("extract only doc id and compare", func(t *testing.T) {
+		id, updateTime, err := DocIDAndTimeFromBinary(asBinary)
+		require.Nil(t, err)
+		assert.Equal(t, uint64(7), id)
+		assert.Equal(t, before.LastUpdateTimeUnix(), updateTime)
+	})
+
+	t.Run("extract single text prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "name")
+		require.Nil(t, err)
+		require.True(t, ok)
+		require.NotEmpty(t, prop)
+		assert.Equal(t, "MyName", prop[0])
+	})
+
+	t.Run("extract non-existing text prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "IDoNotExist")
+		require.Nil(t, err)
+		require.True(t, ok)
+		require.Empty(t, prop)
+	})
+}
+
+func TestStorageObjectMarshallingMultiVector(t *testing.T) {
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"name": "MyName",
+				"foo":  float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector1": {1, 2, 3},
+			"vector2": {4, 5, 6},
+		},
+		map[string][][]float32{
+			"vector3": {{7, 8, 9}, {10, 11, 12}},
+			"vector4": {{13, 14, 15}, {16, 17, 18}, {16, 1}, {1}},
+			"vector5": {{19, 20, 21}, {22, 23, 24}},
+		},
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	after, err := FromBinary(asBinary)
+	require.Nil(t, err)
+
+	t.Run("compare", func(t *testing.T) {
+		assert.Equal(t, before, after)
+	})
+
+	t.Run("extract only doc id and compare", func(t *testing.T) {
+		id, updateTime, err := DocIDAndTimeFromBinary(asBinary)
+		require.Nil(t, err)
+		assert.Equal(t, uint64(7), id)
+		assert.Equal(t, before.LastUpdateTimeUnix(), updateTime)
+	})
+
+	t.Run("extract single text prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "name")
+		require.Nil(t, err)
+		require.True(t, ok)
+		require.NotEmpty(t, prop)
+		assert.Equal(t, "MyName", prop[0])
+	})
+
+	t.Run("extract non-existing text prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "IDoNotExist")
+		require.Nil(t, err)
+		require.True(t, ok)
+		require.Empty(t, prop)
+	})
+}
+
+func TestStorageObjectUnMarshallingMultiVector(t *testing.T) {
+	t.Run("all vectors stored", func(t *testing.T) {
+		before := FromObject(
+			&models.Object{
+				Class:              "MyFavoriteClass",
+				CreationTimeUnix:   123456,
+				LastUpdateTimeUnix: 56789,
+				ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+				Additional: models.AdditionalProperties{
+					"classification": &additional.Classification{
+						BasedOn: []string{"some", "fields"},
+					},
+					"interpretation": map[string]interface{}{
+						"Source": []interface{}{
+							map[string]interface{}{
+								"concept":    "foo",
+								"occurrence": float64(7),
+								"weight":     float64(3),
+							},
+						},
+					},
+				},
+				Properties: map[string]interface{}{
+					"name": "MyName",
+					"foo":  float64(17),
+				},
+			},
+			[]float32{1, 2, 0.7},
+			map[string][]float32{
+				"vector1": {1, 2, 3},
+				"vector2": {4, 5, 6},
+			},
+			map[string][][]float32{
+				"vector3": {{7, 8, 9}, {10, 11, 12}},
+				"vector4": {{13, 14, 15}, {16, 17, 18}, {16, 1}, {1}},
+				"vector5": {{19, 20, 21}, {22, 23, 24}, {22, 23, 24}, {22, 23, 24}, {22, 23, 24}},
+			},
+		)
+		before.DocID = 7
+
+		asBinary, err := before.MarshalBinary()
+		require.Nil(t, err)
+
+		after := &Object{}
+		after.UnmarshalBinary(asBinary)
+		require.Nil(t, err)
+
+		t.Run("compare", func(t *testing.T) {
+			assert.Equal(t, before, after)
+		})
+
+		t.Run("check vector", func(t *testing.T) {
+			require.NotEmpty(t, after.Vector)
+			assert.ElementsMatch(t, after.Vector, before.Vector)
+		})
+
+		t.Run("check vectors", func(t *testing.T) {
+			require.NotEmpty(t, after.Vectors)
+			assert.ElementsMatch(t, after.Vectors["vector1"], before.Vectors["vector1"])
+			assert.ElementsMatch(t, after.Vectors["vector2"], before.Vectors["vector2"])
+		})
+
+		t.Run("check multi vectors", func(t *testing.T) {
+			require.NotEmpty(t, after.MultiVectors)
+			assert.ElementsMatch(t, after.MultiVectors["vector3"], before.MultiVectors["vector3"])
+			assert.ElementsMatch(t, after.MultiVectors["vector4"], before.MultiVectors["vector4"])
+			assert.ElementsMatch(t, after.MultiVectors["vector5"], before.MultiVectors["vector5"])
+		})
+
+		t.Run("check multi vectors optional", func(t *testing.T) {
+			t.Run("FromBinaryOptional: empty additional", func(t *testing.T) {
+				afterMultiVectorsOptional, err := FromBinaryOptional(asBinary, additional.Properties{}, nil)
+				require.Nil(t, err)
+				require.Nil(t, afterMultiVectorsOptional.MultiVectors)
+			})
+
+			t.Run("FromBinaryOptional: multi vector in additional", func(t *testing.T) {
+				afterMultiVectorsOptional, err := FromBinaryOptional(asBinary, additional.Properties{
+					Vectors: []string{"vector4"},
+				}, nil)
+				require.Nil(t, err)
+				require.NotEmpty(t, afterMultiVectorsOptional.MultiVectors)
+				require.Len(t, afterMultiVectorsOptional.MultiVectors, 1)
+				require.Equal(t, before.MultiVectors["vector4"], afterMultiVectorsOptional.MultiVectors["vector4"])
+			})
+
+			t.Run("FromBinaryOptional: named vector and multi vector in additional", func(t *testing.T) {
+				afterMultiVectorsOptional, err := FromBinaryOptional(asBinary, additional.Properties{
+					Vectors: []string{"vector2", "vector4"},
+				}, nil)
+				require.Nil(t, err)
+				require.NotEmpty(t, afterMultiVectorsOptional.Vectors)
+				require.NotEmpty(t, afterMultiVectorsOptional.MultiVectors)
+				require.Len(t, afterMultiVectorsOptional.Vectors, 2)
+				require.Len(t, afterMultiVectorsOptional.MultiVectors, 1)
+				require.Equal(t, before.Vectors["vector1"], afterMultiVectorsOptional.Vectors["vector1"])
+				require.Equal(t, before.Vectors["vector2"], afterMultiVectorsOptional.Vectors["vector2"])
+				require.Equal(t, before.MultiVectors["vector4"], afterMultiVectorsOptional.MultiVectors["vector4"])
+			})
+		})
+	})
+
+	t.Run("only vectors and multivectors", func(t *testing.T) {
+		before := FromObject(
+			&models.Object{
+				Class:              "MyFavoriteClass",
+				CreationTimeUnix:   123456,
+				LastUpdateTimeUnix: 56789,
+				ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+				Additional: models.AdditionalProperties{
+					"classification": &additional.Classification{
+						BasedOn: []string{"some", "fields"},
+					},
+					"interpretation": map[string]interface{}{
+						"Source": []interface{}{
+							map[string]interface{}{
+								"concept":    "foo",
+								"occurrence": float64(7),
+								"weight":     float64(3),
+							},
+						},
+					},
+				},
+				Properties: map[string]interface{}{
+					"name": "MyName",
+					"foo":  float64(17),
+				},
+			},
+			nil,
+			map[string][]float32{
+				"vector1": {1, 2, 3},
+				"vector2": {4, 5, 6},
+			},
+			map[string][][]float32{
+				"vector3": {{7, 8, 9}, {10, 11, 12}},
+				"vector4": {{13, 14, 15}, {16, 17, 18}, {16, 1}, {1}},
+				"vector5": {{19, 20, 21}, {22, 23, 24}, {22, 23, 24}, {22, 23, 24}, {22, 23, 24}},
+			},
+		)
+		before.DocID = 7
+
+		asBinary, err := before.MarshalBinary()
+		require.Nil(t, err)
+
+		after := &Object{}
+		after.UnmarshalBinary(asBinary)
+		require.Nil(t, err)
+
+		t.Run("check vector", func(t *testing.T) {
+			require.Empty(t, after.Vector)
+		})
+
+		t.Run("check vectors", func(t *testing.T) {
+			require.NotEmpty(t, after.Vectors)
+			assert.ElementsMatch(t, after.Vectors["vector1"], before.Vectors["vector1"])
+			assert.ElementsMatch(t, after.Vectors["vector2"], before.Vectors["vector2"])
+		})
+
+		t.Run("check multivectors", func(t *testing.T) {
+			require.NotEmpty(t, after.MultiVectors)
+			assert.ElementsMatch(t, after.MultiVectors["vector3"], before.MultiVectors["vector3"])
+			assert.ElementsMatch(t, after.MultiVectors["vector4"], before.MultiVectors["vector4"])
+			assert.ElementsMatch(t, after.MultiVectors["vector5"], before.MultiVectors["vector5"])
+		})
+	})
+
+	t.Run("only multi vectors", func(t *testing.T) {
+		before := FromObject(
+			&models.Object{
+				Class:              "MyFavoriteClass",
+				CreationTimeUnix:   123456,
+				LastUpdateTimeUnix: 56789,
+				ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+				Additional: models.AdditionalProperties{
+					"classification": &additional.Classification{
+						BasedOn: []string{"some", "fields"},
+					},
+					"interpretation": map[string]interface{}{
+						"Source": []interface{}{
+							map[string]interface{}{
+								"concept":    "foo",
+								"occurrence": float64(7),
+								"weight":     float64(3),
+							},
+						},
+					},
+				},
+				Properties: map[string]interface{}{
+					"name": "MyName",
+					"foo":  float64(17),
+				},
+			},
+			nil,
+			nil,
+			map[string][][]float32{
+				"vector3": {{7, 8, 9}, {10, 11, 12}},
+				"vector4": {{13, 14, 15}, {16, 17, 18}, {16, 1}, {1}},
+				"vector5": {{19, 20, 21}, {22, 23, 24}, {22, 23, 24}, {22, 23, 24}, {22, 23, 24}},
+			},
+		)
+		before.DocID = 7
+
+		asBinary, err := before.MarshalBinary()
+		require.Nil(t, err)
+
+		after := &Object{}
+		after.UnmarshalBinary(asBinary)
+		require.Nil(t, err)
+
+		t.Run("check vector", func(t *testing.T) {
+			require.Empty(t, after.Vector)
+		})
+
+		t.Run("check vectors", func(t *testing.T) {
+			require.Nil(t, after.Vectors)
+		})
+
+		t.Run("check multi vectors", func(t *testing.T) {
+			require.NotEmpty(t, after.MultiVectors)
+			assert.ElementsMatch(t, after.MultiVectors["vector3"], before.MultiVectors["vector3"])
+			assert.ElementsMatch(t, after.MultiVectors["vector4"], before.MultiVectors["vector4"])
+			assert.ElementsMatch(t, after.MultiVectors["vector5"], before.MultiVectors["vector5"])
+		})
+	})
+}
+
+func TestFilteringNilProperty(t *testing.T) {
+	object := FromObject(
+		&models.Object{
+			Class: "MyFavoriteClass",
+			ID:    "73f2eb5f-5abf-447a-81ca-74b1dd168247",
+			Properties: map[string]interface{}{
+				"IWillBeRemoved": nil,
+				"IWillStay":      float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		nil,
+		nil,
+	)
+	props := object.Properties()
+	propsTyped, ok := props.(map[string]interface{})
+	require.True(t, ok)
+	assert.Equal(t, propsTyped["IWillStay"], float64(17))
+
+	elem, ok := propsTyped["IWillBeRemoved"]
+	require.False(t, ok)
+	require.Nil(t, elem)
+}
+
+func TestStorageObjectUnmarshallingSpecificProps(t *testing.T) {
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"name": "MyName",
+				"foo":  float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector1": {1, 2, 3},
+			"vector2": {4, 5, 6},
+			"vector3": {7, 8, 9},
+		},
+		nil,
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	t.Run("without any optional", func(t *testing.T) {
+		after, err := FromBinaryOptional(asBinary, additional.Properties{}, nil)
+		require.Nil(t, err)
+
+		t.Run("compare", func(t *testing.T) {
+			// modify before to match expectations of after
+			before.Object.Additional = nil
+			before.Vector = nil
+			before.VectorLen = 3
+			before.Vectors = nil
+			assert.Equal(t, before, after)
+
+			assert.Equal(t, before.DocID, after.DocID)
+
+			// The vector length should always be returned (for usage metrics
+			// purposes) even if the vector itself is skipped
+			assert.Equal(t, after.VectorLen, 3)
+		})
+	})
+}
+
+func TestNewStorageObject(t *testing.T) {
+	t.Run("objects", func(t *testing.T) {
+		so := New(12)
+
+		t.Run("check index id", func(t *testing.T) {
+			assert.Equal(t, uint64(12), so.DocID)
+		})
+
+		t.Run("is invalid without required params", func(t *testing.T) {
+			assert.False(t, so.Valid())
+		})
+
+		t.Run("reassign index id", func(t *testing.T) {
+			so.DocID = 13
+			assert.Equal(t, uint64(13), so.DocID)
+		})
+
+		t.Run("assign class", func(t *testing.T) {
+			so.SetClass("MyClass")
+			assert.Equal(t, schema.ClassName("MyClass"), so.Class())
+		})
+
+		t.Run("assign uuid", func(t *testing.T) {
+			id := strfmt.UUID("bf706904-8618-463f-899c-4a2aafd48d56")
+			so.SetID(id)
+			assert.Equal(t, id, so.ID())
+		})
+
+		t.Run("assign uuid", func(t *testing.T) {
+			schema := map[string]interface{}{
+				"foo": "bar",
+			}
+			so.SetProperties(schema)
+			assert.Equal(t, schema, so.Properties())
+		})
+
+		t.Run("must now be valid", func(t *testing.T) {
+			assert.True(t, so.Valid())
+		})
+
+		t.Run("make sure it's identical with an object created from an existing object",
+			func(t *testing.T) {
+				alt := FromObject(&models.Object{
+					Class: "MyClass",
+					ID:    "bf706904-8618-463f-899c-4a2aafd48d56",
+					Properties: map[string]interface{}{
+						"foo": "bar",
+					},
+				}, nil, nil, nil)
+				alt.DocID = 13
+
+				assert.Equal(t, so, alt)
+			})
+	})
+
+	t.Run("objects", func(t *testing.T) {
+		so := New(12)
+
+		t.Run("check index id", func(t *testing.T) {
+			assert.Equal(t, uint64(12), so.DocID)
+		})
+
+		t.Run("is invalid without required params", func(t *testing.T) {
+			assert.False(t, so.Valid())
+		})
+
+		t.Run("reassign index id", func(t *testing.T) {
+			so.DocID = 13
+			assert.Equal(t, uint64(13), so.DocID)
+		})
+
+		t.Run("assign class", func(t *testing.T) {
+			so.SetClass("MyClass")
+			assert.Equal(t, schema.ClassName("MyClass"), so.Class())
+		})
+
+		t.Run("assign uuid", func(t *testing.T) {
+			id := strfmt.UUID("bf706904-8618-463f-899c-4a2aafd48d56")
+			so.SetID(id)
+			assert.Equal(t, id, so.ID())
+		})
+
+		t.Run("assign uuid", func(t *testing.T) {
+			schema := map[string]interface{}{
+				"foo": "bar",
+			}
+			so.SetProperties(schema)
+			assert.Equal(t, schema, so.Properties())
+		})
+
+		t.Run("must now be valid", func(t *testing.T) {
+			assert.True(t, so.Valid())
+		})
+
+		t.Run("make sure it's identical with an object created from an existing action",
+			func(t *testing.T) {
+				alt := FromObject(&models.Object{
+					Class: "MyClass",
+					ID:    "bf706904-8618-463f-899c-4a2aafd48d56",
+					Properties: map[string]interface{}{
+						"foo": "bar",
+					},
+				}, nil, nil, nil)
+				alt.DocID = 13
+
+				assert.Equal(t, so, alt)
+			})
+	})
+}
+
+func TestStorageArrayObjectMarshalling(t *testing.T) {
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"textArray":   []string{"c", "d"},
+				"numberArray": []float64{1.1, 2.1},
+				"foo":         float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector1": {1, 2, 3},
+			"vector2": {4, 5, 6},
+			"vector3": {7, 8, 9},
+		},
+		nil,
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	after, err := FromBinary(asBinary)
+	require.Nil(t, err)
+
+	t.Run("compare", func(t *testing.T) {
+		assert.Equal(t, before, after)
+	})
+
+	t.Run("extract only doc id and compare", func(t *testing.T) {
+		id, updateTime, err := DocIDAndTimeFromBinary(asBinary)
+		require.Nil(t, err)
+		assert.Equal(t, uint64(7), id)
+		assert.Equal(t, before.LastUpdateTimeUnix(), updateTime)
+	})
+
+	t.Run("extract text array prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "textArray")
+		require.Nil(t, err)
+		require.True(t, ok)
+		assert.Equal(t, []string{"c", "d"}, prop)
+	})
+
+	t.Run("extract number array prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractNumberArrayProp(asBinary, "numberArray")
+		require.Nil(t, err)
+		require.True(t, ok)
+		assert.Equal(t, []float64{1.1, 2.1}, prop)
+	})
+}
+
+func TestExtractionOfSingleProperties(t *testing.T) {
+	expected := map[string]interface{}{
+		"numberArray":  []interface{}{1.1, 2.1},
+		"intArray":     []interface{}{1., 2., 5000.},
+		"textArrayUTF": []interface{}{"語", "b"},
+		"textArray":    []interface{}{"hello", ",", "I", "am", "a", "veeery", "long", "Array", "with some text."},
+		"foo":          float64(17),
+		"text":         "single string",
+		"bool":         true,
+		"time":         "2011-11-23T01:52:23.000004234Z",
+		"boolArray":    []interface{}{true, false, true},
+		"beacon":       []interface{}{map[string]interface{}{"beacon": "weaviate://localhost/SomeClass/3453/73f4eb5f-5abf-447a-81ca-74b1dd168247"}},
+		"ref": []interface{}{
+			map[string]interface{}{"beacon": "weaviate://localhost/SomeClass/3453/73f4eb5f-5abf-447a-81ca-74b1dd168247"},
+			map[string]interface{}{"beacon": "weaviate://localhost/SomeClass/3453/73f4eb5f-5abf-447a-81ca-74b1dd168248"},
+		},
+		"nested":      map[string]interface{}{"test": map[string]interface{}{"innerInt": float64(3), "innerStr": "avc"}},
+		"nestedArray": []interface{}{map[string]interface{}{"test": map[string]interface{}{"innerArray": float64(3), "innerStr": "avc"}}},
+	}
+	properties := map[string]interface{}{
+		"numberArray":  []float64{1.1, 2.1},
+		"intArray":     []int32{1, 2, 5000},
+		"textArrayUTF": []string{"語", "b"},
+		"textArray":    []string{"hello", ",", "I", "am", "a", "veeery", "long", "Array", "with some text."},
+		"foo":          float64(17),
+		"text":         "single string",
+		"bool":         true,
+		"time":         time.Date(2011, 11, 23, 1, 52, 23, 4234, time.UTC),
+		"boolArray":    []bool{true, false, true},
+		"beacon":       []map[string]interface{}{{"beacon": "weaviate://localhost/SomeClass/3453/73f4eb5f-5abf-447a-81ca-74b1dd168247"}},
+		"ref": []models.SingleRef{
+			{Beacon: "weaviate://localhost/SomeClass/3453/73f4eb5f-5abf-447a-81ca-74b1dd168247", Class: "OtherClass", Href: "/v1/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"},
+			{Beacon: "weaviate://localhost/SomeClass/3453/73f4eb5f-5abf-447a-81ca-74b1dd168248", Class: "OtherClass", Href: "/v1/f81bfe5e-16ba-4615-a516-46c2ae2e5a81"},
+		},
+		"nested":      map[string]interface{}{"test": map[string]interface{}{"innerInt": 3, "innerStr": "avc"}},
+		"nestedArray": []interface{}{map[string]interface{}{"test": map[string]interface{}{"innerArray": float64(3), "innerStr": "avc"}}},
+	}
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 "73f2eb5f-5abf-447a-81ca-74b1dd168247",
+			Properties:         properties,
+		},
+		[]float32{1, 2, 0.7},
+		nil,
+		nil,
+	)
+
+	before.DocID = 7
+	byteObject, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	var propStrings [][]string
+	for key := range properties {
+		propStrings = append(propStrings, []string{key})
+	}
+
+	extractedProperties := map[string]interface{}{}
+
+	// test with reused property map
+	for i := 0; i < 2; i++ {
+		require.Nil(t, UnmarshalPropertiesFromObject(byteObject, extractedProperties, propStrings))
+		for key := range expected {
+			require.Equal(t, expected[key], extractedProperties[key])
+		}
+	}
+}
+
+func TestStorageObjectMarshallingWithGroup(t *testing.T) {
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+				"group": &additional.Group{
+					ID: 100,
+					GroupedBy: &additional.GroupedBy{
+						Value: "group-by-some-property",
+						Path:  []string{"property-path"},
+					},
+					MaxDistance: 0.1,
+					MinDistance: 0.2,
+					Count:       200,
+					Hits: []map[string]interface{}{
+						{
+							"property1": "value1",
+							"_additional": &additional.GroupHitAdditional{
+								ID:       "2c76ca18-2073-4c48-aa52-7f444d2f5b80",
+								Distance: 0.24,
+							},
+						},
+						{
+							"property1": "value2",
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"name": "MyName",
+				"foo":  float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector1": {1, 2, 3},
+			"vector2": {4, 5, 6},
+			"vector3": {7, 8, 9},
+		},
+		nil,
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	after, err := FromBinary(asBinary)
+	require.Nil(t, err)
+
+	t.Run("compare", func(t *testing.T) {
+		assert.Equal(t, before, after)
+	})
+
+	t.Run("extract only doc id and compare", func(t *testing.T) {
+		id, updateTime, err := DocIDAndTimeFromBinary(asBinary)
+		require.Nil(t, err)
+		assert.Equal(t, uint64(7), id)
+		assert.Equal(t, before.LastUpdateTimeUnix(), updateTime)
+	})
+
+	t.Run("extract single text prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "name")
+		require.Nil(t, err)
+		require.True(t, ok)
+		require.NotEmpty(t, prop)
+		assert.Equal(t, "MyName", prop[0])
+	})
+
+	t.Run("extract non-existing text prop", func(t *testing.T) {
+		prop, ok, err := ParseAndExtractTextProp(asBinary, "IDoNotExist")
+		require.Nil(t, err)
+		require.True(t, ok)
+		require.Empty(t, prop)
+	})
+
+	t.Run("extract group additional property", func(t *testing.T) {
+		require.NotNil(t, after.AdditionalProperties())
+		require.NotNil(t, after.AdditionalProperties()["group"])
+		group, ok := after.AdditionalProperties()["group"].(*additional.Group)
+		require.True(t, ok)
+		assert.Equal(t, 100, group.ID)
+		assert.NotNil(t, group.GroupedBy)
+		assert.Equal(t, "group-by-some-property", group.GroupedBy.Value)
+		assert.Equal(t, []string{"property-path"}, group.GroupedBy.Path)
+		assert.Equal(t, 200, group.Count)
+		assert.Equal(t, float32(0.1), group.MaxDistance)
+		assert.Equal(t, float32(0.2), group.MinDistance)
+		require.Len(t, group.Hits, 2)
+		require.NotNil(t, group.Hits[0]["_additional"])
+		groupHitAdditional, ok := group.Hits[0]["_additional"].(*additional.GroupHitAdditional)
+		require.True(t, ok)
+		assert.Equal(t, strfmt.UUID("2c76ca18-2073-4c48-aa52-7f444d2f5b80"), groupHitAdditional.ID)
+		assert.Equal(t, float32(0.24), groupHitAdditional.Distance)
+		assert.Equal(t, "value1", group.Hits[0]["property1"])
+		require.Nil(t, group.Hits[1]["_additional"])
+		assert.Equal(t, "value2", group.Hits[1]["property1"])
+	})
+}
+
+func TestStorageMaxVectorDimensionsObjectMarshalling(t *testing.T) {
+	generateVector := func(dims uint16) []float32 {
+		vector := make([]float32, dims)
+		for i := range vector {
+			vector[i] = 0.1
+		}
+		return vector
+	}
+	// 65535 is max uint16 number
+	edgeVectorLengths := []uint16{0, 1, 768, 50000, 65535}
+	for _, vectorLength := range edgeVectorLengths {
+		t.Run(fmt.Sprintf("%v vector dimensions", vectorLength), func(t *testing.T) {
+			t.Run("marshal binary", func(t *testing.T) {
+				vector := generateVector(vectorLength)
+				before := FromObject(
+					&models.Object{
+						Class:            "MyFavoriteClass",
+						CreationTimeUnix: 123456,
+						ID:               strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+						Properties: map[string]interface{}{
+							"name": "myName",
+						},
+					},
+					vector,
+					nil,
+					nil,
+				)
+				before.DocID = 7
+
+				asBinary, err := before.MarshalBinary()
+				require.Nil(t, err)
+
+				after, err := FromBinary(asBinary)
+				require.Nil(t, err)
+
+				t.Run("compare", func(t *testing.T) {
+					assert.Equal(t, before, after)
+				})
+
+				t.Run("try to extract a property", func(t *testing.T) {
+					prop, ok, err := ParseAndExtractTextProp(asBinary, "name")
+					require.Nil(t, err)
+					require.True(t, ok)
+					assert.Equal(t, []string{"myName"}, prop)
+				})
+			})
+
+			t.Run("marshal optional binary", func(t *testing.T) {
+				vector := generateVector(vectorLength)
+				before := FromObject(
+					&models.Object{
+						Class:            "MyFavoriteClass",
+						CreationTimeUnix: 123456,
+						ID:               strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+						Properties: map[string]interface{}{
+							"name":   "myName",
+							"second": "entry",
+						},
+					},
+					vector,
+					nil,
+					nil,
+				)
+				before.DocID = 7
+
+				asBinary, err := before.MarshalBinary()
+				require.Nil(t, err)
+
+				t.Run("get without additional properties", func(t *testing.T) {
+					after, err := FromBinaryOptional(asBinary, additional.Properties{}, nil)
+					require.Nil(t, err)
+					// modify before to match expectations of after
+					before.Object.Additional = nil
+					before.Vector = nil
+					before.VectorLen = int(vectorLength)
+					assert.Equal(t, before, after)
+
+					assert.Equal(t, before.DocID, after.DocID)
+
+					// The vector length should always be returned (for usage metrics
+					// purposes) even if the vector itself is skipped
+					assert.Equal(t, after.VectorLen, int(vectorLength))
+				})
+
+				t.Run("get with additional property vector", func(t *testing.T) {
+					after, err := FromBinaryOptional(asBinary, additional.Properties{Vector: true}, nil)
+					require.Nil(t, err)
+					// modify before to match expectations of after
+					before.Object.Additional = nil
+					before.Vector = vector
+					before.VectorLen = int(vectorLength)
+
+					assert.Equal(t, before, after)
+
+					assert.Equal(t, before.DocID, after.DocID)
+
+					// The vector length should always be returned (for usage metrics
+					// purposes) even if the vector itself is skipped
+					assert.Equal(t, after.VectorLen, int(vectorLength))
+					assert.Equal(t, vector, after.Vector)
+				})
+
+				t.Run("with explicit properties", func(t *testing.T) {
+					after, err := FromBinaryOptional(asBinary, additional.Properties{},
+						&PropertyExtraction{PropertyPaths: [][]string{{"name"}}},
+					)
+					require.Nil(t, err)
+
+					assert.Equal(t, before.DocID, after.DocID)
+					// second property is not included
+					assert.Equal(t, map[string]interface{}{"name": "myName"}, after.Properties())
+				})
+
+				t.Run("test no props and moduleparams", func(t *testing.T) {
+					after, err := FromBinaryOptional(asBinary, additional.Properties{
+						NoProps:      true,
+						ModuleParams: map[string]interface{}{"foo": "bar"}, // this causes the property extraction code to run
+					},
+						&PropertyExtraction{PropertyPaths: nil},
+					)
+					require.Nil(t, err)
+
+					assert.Equal(t, before.DocID, after.DocID)
+					var emptyProps map[string]interface{}
+					assert.Equal(t, emptyProps, after.Properties())
+				})
+			})
+		})
+	}
+}
+
+func TestVectorFromBinary(t *testing.T) {
+	vector1 := []float32{1, 2, 3}
+	vector2 := []float32{4, 5, 6}
+	vector3 := []float32{7, 8, 9}
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+				"group": &additional.Group{
+					ID: 100,
+					GroupedBy: &additional.GroupedBy{
+						Value: "group-by-some-property",
+						Path:  []string{"property-path"},
+					},
+					MaxDistance: 0.1,
+					MinDistance: 0.2,
+					Count:       200,
+					Hits: []map[string]interface{}{
+						{
+							"property1": "value1",
+							"_additional": &additional.GroupHitAdditional{
+								ID:       "2c76ca18-2073-4c48-aa52-7f444d2f5b80",
+								Distance: 0.24,
+							},
+						},
+						{
+							"property1": "value2",
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"name": "MyName",
+				"foo":  float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector1": vector1,
+			"vector2": vector2,
+			"vector3": vector3,
+		},
+		nil,
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	outVector1, err := VectorFromBinary(asBinary, nil, "vector1")
+	require.Nil(t, err)
+	assert.Equal(t, vector1, outVector1)
+
+	outVector2, err := VectorFromBinary(asBinary, nil, "vector2")
+	require.Nil(t, err)
+	assert.Equal(t, vector2, outVector2)
+
+	outVector3, err := VectorFromBinary(asBinary, nil, "vector3")
+	require.Nil(t, err)
+	assert.Equal(t, vector3, outVector3)
+}
+
+func TestMultiVectorFromBinary(t *testing.T) {
+	vector1 := [][]float32{{1, 2, 3}, {4, 5, 6}}
+	vector2 := [][]float32{{4, 5, 6}, {7, 8, 9}}
+	vector3 := [][]float32{{7, 8, 9}, {10, 11, 12}, {13, 14, 15}}
+	vector4 := []float32{1, 2, 3}
+	before := FromObject(
+		&models.Object{
+			Class:              "MyFavoriteClass",
+			CreationTimeUnix:   123456,
+			LastUpdateTimeUnix: 56789,
+			ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			Additional: models.AdditionalProperties{
+				"classification": &additional.Classification{
+					BasedOn: []string{"some", "fields"},
+				},
+				"interpretation": map[string]interface{}{
+					"Source": []interface{}{
+						map[string]interface{}{
+							"concept":    "foo",
+							"occurrence": float64(7),
+							"weight":     float64(3),
+						},
+					},
+				},
+				"group": &additional.Group{
+					ID: 100,
+					GroupedBy: &additional.GroupedBy{
+						Value: "group-by-some-property",
+						Path:  []string{"property-path"},
+					},
+					MaxDistance: 0.1,
+					MinDistance: 0.2,
+					Count:       200,
+					Hits: []map[string]interface{}{
+						{
+							"property1": "value1",
+							"_additional": &additional.GroupHitAdditional{
+								ID:       "2c76ca18-2073-4c48-aa52-7f444d2f5b80",
+								Distance: 0.24,
+							},
+						},
+						{
+							"property1": "value2",
+						},
+					},
+				},
+			},
+			Properties: map[string]interface{}{
+				"name": "MyName",
+				"foo":  float64(17),
+			},
+		},
+		[]float32{1, 2, 0.7},
+		map[string][]float32{
+			"vector4": vector4,
+		},
+		map[string][][]float32{
+			"vector1": vector1,
+			"vector2": vector2,
+			"vector3": vector3,
+		},
+	)
+	before.DocID = 7
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(t, err)
+
+	outVector1, err := MultiVectorFromBinary(asBinary, nil, "vector1")
+	require.Nil(t, err)
+	assert.Equal(t, vector1, outVector1)
+
+	outVector2, err := MultiVectorFromBinary(asBinary, nil, "vector2")
+	require.Nil(t, err)
+	assert.Equal(t, vector2, outVector2)
+
+	outVector3, err := MultiVectorFromBinary(asBinary, nil, "vector3")
+	require.Nil(t, err)
+	assert.Equal(t, vector3, outVector3)
+
+	outVector4, err := VectorFromBinary(asBinary, nil, "vector4")
+	require.Nil(t, err)
+	assert.Equal(t, vector4, outVector4)
+}
+
+func TestStorageInvalidObjectMarshalling(t *testing.T) {
+	t.Run("invalid className", func(t *testing.T) {
+		invalidClassName := make([]byte, maxClassNameLength+1)
+		cryptorand.Read(invalidClassName[:])
+
+		invalidObj := FromObject(
+			&models.Object{
+				Class:              string(invalidClassName),
+				CreationTimeUnix:   123456,
+				LastUpdateTimeUnix: 56789,
+				ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			},
+			nil,
+			nil,
+			nil,
+		)
+
+		_, err := invalidObj.MarshalBinary()
+		require.ErrorContains(t, err, "could not marshal 'className' max length exceeded")
+	})
+
+	t.Run("invalid vector", func(t *testing.T) {
+		invalidObj := FromObject(
+			&models.Object{
+				Class:              "classA",
+				CreationTimeUnix:   123456,
+				LastUpdateTimeUnix: 56789,
+				ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			},
+			make([]float32, maxVectorLength+1),
+			nil,
+			nil,
+		)
+
+		_, err := invalidObj.MarshalBinary()
+		require.ErrorContains(t, err, "could not marshal 'vector' max length exceeded")
+	})
+
+	t.Run("invalid named vector size", func(t *testing.T) {
+		invalidObj := FromObject(
+			&models.Object{
+				Class:              "classA",
+				CreationTimeUnix:   123456,
+				LastUpdateTimeUnix: 56789,
+				ID:                 strfmt.UUID("73f2eb5f-5abf-447a-81ca-74b1dd168247"),
+			},
+			nil,
+			map[string][]float32{
+				"vector1": make([]float32, maxVectorLength+1),
+			},
+			nil,
+		)
+
+		_, err := invalidObj.MarshalBinary()
+		require.ErrorContains(t, err, "could not marshal 'vector' max length exceeded")
+	})
+}
+
+// Test that using the same buffer as source for unmarshalling does not cause problems due to memoy reuse
+func TestMemoryReuse(t *testing.T) {
+	props := []map[string]interface{}{
+		{
+			"numberArray":  []interface{}{1.1, 2.1},
+			"intArray":     []interface{}{1., 2., 5000.},
+			"textArrayUTF": []interface{}{"語", "b"},
+			"boolArray":    []interface{}{true, false},
+			"textArray":    []interface{}{"hello", ",", "I", "am", "a", "veeery", "long", "Array", "with some text."},
+			"ref":          []interface{}{map[string]interface{}{"beacon": "weaviate://localhost/SomeClass/73f4eb5f-5abf-447a-81ca-74b1dd168247"}},
+			"foo":          float64(17),
+		},
+		{
+			"numberArray":  []interface{}{1.4, 6.1},
+			"intArray":     []interface{}{4., 3., 9000.},
+			"textArrayUTF": []interface{}{"a", "c"},
+			"boolArray":    []interface{}{true, true},
+			"textArray":    []interface{}{"I", "contain", "other", "text"},
+			"ref":          []interface{}{map[string]interface{}{"beacon": "weaviate://localhost/SomeClass/73f4eb5f-5abf-447a-81ca-74b1dd168248"}},
+			"foo":          float64(5),
+		},
+		{
+			"numberArray":  []interface{}{1.4, 6.1, 8.9},
+			"intArray":     []interface{}{4., 3., 9000., 1.},
+			"textArrayUTF": []interface{}{"a", "c", "d"},
+			"boolArray":    []interface{}{true, true, false},
+			"textArray":    []interface{}{"I", "contain", "other", "text", "too"},
+			"ref":          []interface{}{map[string]interface{}{"beacon": "weaviate://localhost/SomeClass/73f4eb5f-5abf-447a-81ca-74b1dd168249"}},
+			"foo":          float64(9),
+		},
+	}
+
+	largestSize := 0
+	for i, prop := range props {
+		obj := models.Object{
+			Class:      "something",
+			ID:         strfmt.UUID(fmt.Sprintf("73f4eb5f-5abf-447a-81ca-74b1dd16824%v", i)),
+			Properties: prop,
+		}
+		before := FromObject(&obj, nil, nil, nil)
+		asBinary, err := before.MarshalBinary()
+		require.Nil(t, err)
+		if len(asBinary) > largestSize {
+			largestSize = len(asBinary)
+		}
+	}
+
+	reuseableBuff := make([]byte, largestSize)
+	afterProps := []map[string]interface{}{}
+	for i, beforeProp := range props {
+		obj := models.Object{
+			Class:      "something",
+			ID:         strfmt.UUID(fmt.Sprintf("73f4eb5f-5abf-447a-81ca-74b1dd16824%v", i)),
+			Properties: beforeProp,
+		}
+
+		propertyPaths := make([][]string, 0, len(beforeProp))
+		for j := range beforeProp {
+			propertyPaths = append(propertyPaths, []string{j})
+		}
+
+		before := FromObject(&obj, nil, nil, nil)
+		asBinary, err := before.MarshalBinary()
+		require.Nil(t, err)
+		reuseableBuff = reuseableBuff[:len(asBinary)]
+		copy(reuseableBuff, asBinary)
+
+		afterProp := map[string]interface{}{}
+		require.Nil(t, UnmarshalProperties(reuseableBuff, afterProp, propertyPaths))
+		afterProps = append(afterProps, afterProp)
+	}
+
+	for i, afterProp := range afterProps {
+		assert.Equal(t, props[i], afterProp)
+	}
+}
+
+func BenchmarkUnmarshalPropertiesFullObject(b *testing.B) {
+	benchmarkExtraction(b, nil)
+}
+
+func BenchmarkUnmarshalPropertiesExplicitOnlySome(b *testing.B) {
+	benchmarkExtraction(b, []string{"name", "second"})
+}
+
+func BenchmarkUnmarshalPropertiesExplicitAll(b *testing.B) {
+	benchmarkExtraction(b, []string{"name", "second", "number", "bool", "array"})
+}
+
+func benchmarkExtraction(b *testing.B, propStrings []string) {
+	beforeProps := map[string]interface{}{
+		"name":   "some long string",
+		"second": "other very long string",
+		"number": float64(17),
+		"bool":   false,
+		"array":  []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
+	}
+	before := FromObject(
+		&models.Object{
+			Class:            "MyFavoriteClass",
+			CreationTimeUnix: 123456,
+			ID:               "73f2eb5f-5abf-447a-81ca-74b1dd168247",
+			Properties:       beforeProps,
+		},
+		nil,
+		nil,
+		nil,
+	)
+	before.DocID = 7
+	var props *PropertyExtraction
+
+	if len(propStrings) > 0 {
+		propertyPaths := make([][]string, len(propStrings))
+		for i, prop := range propStrings {
+			propertyPaths[i] = []string{prop}
+		}
+
+		props = &PropertyExtraction{
+			PropertyPaths: propertyPaths,
+		}
+	}
+
+	asBinary, err := before.MarshalBinary()
+	require.Nil(b, err)
+
+	b.ResetTimer()
+
+	for n := 0; n < b.N; n++ {
+		after, err := FromBinaryOptional(asBinary, additional.Properties{}, props)
+		require.Nil(b, err)
+		require.NotNil(b, after)
+	}
+}
+
+func TestObjectsByDocID(t *testing.T) {
+	// the main variable is the input length here which has an effect on chunking
+	// and parallelization
+	tests := []struct {
+		name     string
+		inputIDs []uint64
+		// there is no flag for expected output as that is deterministic based on
+		// the doc ID, we use a convention for the UUID and set a specific prop
+		// exactly to the doc ID.
+	}{
+		{
+			name:     "1 object - sequential code path",
+			inputIDs: []uint64{0},
+		},
+		{
+			name:     "2 objects - concurrent code path",
+			inputIDs: []uint64{0, 1},
+		},
+		{
+			name:     "10 objects - consecutive from beginning",
+			inputIDs: []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+		},
+		{
+			name: "30 objects - consecutive from beginning",
+			inputIDs: []uint64{
+				0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+				17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+			},
+		},
+		{
+			name:     "100 objects - random - should perfectly match to divide into groups",
+			inputIDs: pickRandomIDsBetween(0, 1000, 100),
+		},
+		{
+			name:     "99 objects - random - uneven groups slightly below perfect chunk size",
+			inputIDs: pickRandomIDsBetween(0, 1000, 99),
+		},
+		{
+			name:     "101 objects - random - uneven groups slightly above perfect chunk size",
+			inputIDs: pickRandomIDsBetween(0, 1000, 101),
+		},
+		{
+			name:     "117 objects - random - because why not",
+			inputIDs: pickRandomIDsBetween(0, 1000, 117),
+		},
+	}
+
+	logger, _ := test.NewNullLogger()
+
+	bucket := genFakeBucket(t, 1000)
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := ObjectsByDocID(bucket, test.inputIDs, additional.Properties{}, nil, logger)
+			require.Nil(t, err)
+			require.Len(t, res, len(test.inputIDs))
+
+			for i, obj := range res {
+				expectedDocID := test.inputIDs[i]
+				assert.Equal(t, expectedDocID, uint64(obj.Properties().(map[string]any)["i"].(float64)))
+				expectedUUID := strfmt.UUID(fmt.Sprintf("73f2eb5f-5abf-447a-81ca-74b1dd1%05d", expectedDocID))
+				assert.Equal(t, expectedUUID, obj.ID())
+			}
+		})
+	}
+}
+
+func TestSkipMissingObjects(t *testing.T) {
+	bucket := genFakeBucket(t, 1000)
+	logger, _ := test.NewNullLogger()
+	ids := pickRandomIDsBetween(0, 1000, 100)
+	ids = append(ids, 1001, 1002, 1003)
+	objs, err := objectsByDocIDParallel(bucket, ids, additional.Properties{}, nil, logger)
+	require.Nil(t, err)
+	require.Len(t, objs, 100)
+	for _, obj := range objs {
+		require.NotNil(t, obj)
+	}
+}
+
+func TestIterateThroughVectorDimensions(t *testing.T) {
+	for _, tt := range []struct {
+		name   string
+		object Object
+
+		expect map[string]int
+	}{
+		{
+			name:   "empty",
+			object: Object{},
+			expect: map[string]int{},
+		},
+		{
+			name: "legacy",
+			object: Object{
+				Vector: make([]float32, 100),
+			},
+			expect: map[string]int{
+				"": 100,
+			},
+		},
+		{
+			name: "named",
+			object: Object{
+				Vectors: map[string][]float32{
+					"vec1": make([]float32, 100),
+					"vec2": make([]float32, 200),
+				},
+			},
+			expect: map[string]int{
+				"vec1": 100,
+				"vec2": 200,
+			},
+		},
+		{
+			name: "multi",
+			object: Object{
+				MultiVectors: map[string][][]float32{
+					"vec1": {
+						make([]float32, 100),
+						make([]float32, 200),
+						make([]float32, 300),
+					},
+					"vec2": {
+						make([]float32, 400),
+						make([]float32, 500),
+					},
+				},
+			},
+			expect: map[string]int{
+				"vec1": 600,
+				"vec2": 900,
+			},
+		},
+		{
+			name: "mixed",
+			object: Object{
+				Vector: make([]float32, 100),
+				Vectors: map[string][]float32{
+					"vec1": make([]float32, 200),
+					"vec2": make([]float32, 300),
+				},
+				MultiVectors: map[string][][]float32{
+					"vec3": {
+						make([]float32, 400),
+					},
+					"vec4": {
+						make([]float32, 500),
+					},
+				},
+			},
+			expect: map[string]int{
+				"":     100,
+				"vec1": 200,
+				"vec2": 300,
+				"vec3": 400,
+				"vec4": 500,
+			},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			captured := map[string]int{}
+			err := tt.object.IterateThroughVectorDimensions(func(targetVector string, dims int) error {
+				captured[targetVector] += dims
+				return nil
+			})
+			require.NoError(t, err)
+			require.Equal(t, tt.expect, captured)
+		})
+	}
+}
+
+func BenchmarkObjectsByDocID(b *testing.B) {
+	bucket := genFakeBucket(b, 10000)
+	logger, _ := test.NewNullLogger()
+	ids := pickRandomIDsBetween(0, 10000, 100)
+
+	tests := []struct {
+		concurrent bool
+		amount     int
+	}{
+		{concurrent: true, amount: 1},
+		{concurrent: false, amount: 1},
+		{concurrent: true, amount: 2},
+		{concurrent: false, amount: 2},
+		{concurrent: true, amount: 10},
+		{concurrent: false, amount: 10},
+		{concurrent: true, amount: 100},
+		{concurrent: false, amount: 100},
+	}
+	b.ResetTimer()
+
+	for _, tt := range tests {
+		b.Run(fmt.Sprintf("Concurrent: %v with amount: %v", tt.concurrent, tt.amount), func(t *testing.B) {
+			for i := 0; i < b.N; i++ {
+				if tt.concurrent {
+					_, err := objectsByDocIDParallel(bucket, ids[:tt.amount], additional.Properties{}, nil, logger)
+					require.Nil(t, err)
+
+				} else {
+					_, err := objectsByDocIDSequential(bucket, ids[:tt.amount], additional.Properties{}, nil)
+					require.Nil(t, err)
+				}
+			}
+		})
+	}
+}
+
+func intsToBytes(ints ...uint64) []byte {
+	byteOps := byteops.NewReadWriter(make([]byte, len(ints)*8))
+	for _, i := range ints {
+		byteOps.WriteUint64(i)
+	}
+	return byteOps.Buffer
+}
+
+func FuzzObjectGet(f *testing.F) {
+	maxSize := uint64(9999)
+	logger, _ := test.NewNullLogger()
+	bucket := genFakeBucket(f, maxSize)
+
+	readTests := []struct {
+		ids []uint64
+	}{
+		{ids: []uint64{0}},
+		{ids: []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
+		{ids: pickRandomIDsBetween(0, 1000, 100)},
+	}
+	for _, tc := range readTests {
+		f.Add(intsToBytes(tc.ids...)) // Use f.Add to provide a seed corpus
+	}
+	f.Fuzz(func(t *testing.T, data []byte) {
+		if len(data) == 0 || len(data)%8 != 0 {
+			return
+		}
+		ids := make([]uint64, len(data)/8)
+		for i := 0; i < len(ids); i++ {
+			ids[i] = binary.LittleEndian.Uint64(data[i*8 : (i+1)*8])
+			if ids[i] >= maxSize {
+				return
+			}
+		}
+
+		res, err := ObjectsByDocID(bucket, ids, additional.Properties{}, nil, logger)
+		require.Nil(t, err)
+		require.Len(t, res, len(ids))
+		for i, obj := range res {
+			expectedDocID := ids[i]
+			assert.Equal(t, expectedDocID, uint64(obj.Properties().(map[string]any)["i"].(float64)))
+			expectedUUID := strfmt.UUID(fmt.Sprintf("73f2eb5f-5abf-447a-81ca-74b1dd1%05d", expectedDocID))
+			assert.Equal(t, expectedUUID, obj.ID())
+		}
+	})
+}
+
+type fakeBucket struct {
+	objects map[uint64][]byte
+}
+
+func (f *fakeBucket) GetBySecondary(_ int, _ []byte) ([]byte, error) {
+	panic("not implemented")
+}
+
+func (f *fakeBucket) GetBySecondaryWithBuffer(indexID int, docIDBytes []byte, lsmBuf []byte) ([]byte, []byte, error) {
+	docID := binary.LittleEndian.Uint64(docIDBytes)
+	objBytes, ok := f.objects[docID]
+	if !ok {
+		return nil, nil, nil
+	}
+	if len(lsmBuf) < len(objBytes) {
+		lsmBuf = make([]byte, len(objBytes))
+	}
+
+	copy(lsmBuf, objBytes)
+	return lsmBuf[:len(objBytes)], lsmBuf, nil
+}
+
+func genFakeBucket(t testing.TB, maxSize uint64) *fakeBucket {
+	bucket := &fakeBucket{objects: map[uint64][]byte{}}
+	for i := uint64(0); i < maxSize; i++ {
+		obj := New(i)
+		obj.SetProperties(map[string]any{"i": i, "foo": strings.Repeat("bar", int(i))})
+		obj.SetClass("MyClass")
+		obj.SetID(strfmt.UUID(fmt.Sprintf("73f2eb5f-5abf-447a-81ca-74b1dd1%05d", i)))
+		objBytes, err := obj.MarshalBinary()
+		require.Nil(t, err)
+		bucket.objects[i] = objBytes
+	}
+
+	return bucket
+}
+
+func pickRandomIDsBetween(start, end uint64, count int) []uint64 {
+	ids := make([]uint64, count)
+	for i := 0; i < count; i++ {
+		ids[i] = start + uint64(rand.Intn(int(end-start)))
+	}
+	return ids
+}

platform/dbops/binaries/weaviate-src/entities/sync/sync.go

@@ -0,0 +1,112 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package sync
+
+import (
+	"sync"
+)
+
+// KeyLocker it is a thread safe wrapper of sync.Map
+// Usage: it's used in order to lock specific key in a map
+// to synchronize concurrent access to a code block.
+//
+//	locker.Lock(id)
+//	defer locker.Unlock(id)
+type KeyLocker struct {
+	m sync.Map
+}
+
+// NewKeyLocker creates Keylocker
+func NewKeyLocker() *KeyLocker {
+	return &KeyLocker{
+		m: sync.Map{},
+	}
+}
+
+// Lock it locks a specific bucket by it's ID
+// to hold ant concurrent access to that specific item
+//
+//	do not forget calling Unlock() after locking it.
+func (s *KeyLocker) Lock(ID string) {
+	iLock := &sync.Mutex{}
+	iLocks, _ := s.m.LoadOrStore(ID, iLock)
+
+	iLock = iLocks.(*sync.Mutex)
+	iLock.Lock()
+}
+
+// Unlock it unlocks a specific item by it's ID
+func (s *KeyLocker) Unlock(ID string) {
+	iLocks, _ := s.m.Load(ID)
+	iLock := iLocks.(*sync.Mutex)
+	iLock.Unlock()
+}
+
+// KeyRWLocker it is a thread safe wrapper of sync.Map
+// Usage: it's used in order to lock/rlock specific key in a map
+// to synchronize concurrent access to a code block.
+//
+//	locker.Lock(id)
+//	defer locker.Unlock(id)
+//
+// or
+//
+//	locker.RLock(id)
+//	defer locker.RUnlock(id)
+type KeyRWLocker struct {
+	m sync.Map
+}
+
+// NewKeyLocker creates Keylocker
+func NewKeyRWLocker() *KeyRWLocker {
+	return &KeyRWLocker{
+		m: sync.Map{},
+	}
+}
+
+// Lock it locks a specific bucket by it's ID
+// to hold ant concurrent access to that specific item
+//
+//	do not forget calling Unlock() after locking it.
+func (s *KeyRWLocker) Lock(ID string) {
+	iLock := &sync.RWMutex{}
+	iLocks, _ := s.m.LoadOrStore(ID, iLock)
+
+	iLock = iLocks.(*sync.RWMutex)
+	iLock.Lock()
+}
+
+// Unlock it unlocks a specific item by it's ID
+func (s *KeyRWLocker) Unlock(ID string) {
+	iLocks, _ := s.m.Load(ID)
+	iLock := iLocks.(*sync.RWMutex)
+	iLock.Unlock()
+}
+
+// RLock it rlocks a specific bucket by it's ID
+// to hold ant concurrent access to that specific item
+//
+//	do not forget calling RUnlock() after rlocking it.
+func (s *KeyRWLocker) RLock(ID string) {
+	iLock := &sync.RWMutex{}
+	iLocks, _ := s.m.LoadOrStore(ID, iLock)
+
+	iLock = iLocks.(*sync.RWMutex)
+	iLock.RLock()
+}
+
+// RUnlock it runlocks a specific item by it's ID
+func (s *KeyRWLocker) RUnlock(ID string) {
+	iLocks, _ := s.m.Load(ID)
+	iLock := iLocks.(*sync.RWMutex)
+	iLock.RUnlock()
+}

platform/dbops/binaries/weaviate-src/entities/sync/sync_test.go

@@ -0,0 +1,116 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package sync
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func mutexLocked(m *sync.Mutex) bool {
+	rlocked := m.TryLock()
+	if rlocked {
+		defer m.Unlock()
+	}
+	return !rlocked
+}
+
+func rwMutexLocked(m *sync.RWMutex) bool {
+	// can not RLock
+	rlocked := m.TryRLock()
+	if rlocked {
+		defer m.RUnlock()
+	}
+	return !rlocked
+}
+
+func rwMutexRLocked(m *sync.RWMutex) bool {
+	// can not Lock, but can RLock
+	locked := m.TryLock()
+	if locked {
+		defer m.Unlock()
+		return false
+	}
+	rlocked := m.TryRLock()
+	if rlocked {
+		defer m.RUnlock()
+	}
+	return rlocked
+}
+
+func TestKeyLockerLockUnlock(t *testing.T) {
+	r := require.New(t)
+	s := NewKeyLocker()
+
+	s.Lock("t1")
+	lock, _ := s.m.Load("t1")
+	r.True(mutexLocked(lock.(*sync.Mutex)))
+
+	s.Unlock("t1")
+	lock, _ = s.m.Load("t1")
+	r.False(mutexLocked(lock.(*sync.Mutex)))
+
+	s.Lock("t2")
+	lock, _ = s.m.Load("t2")
+	r.True(mutexLocked(lock.(*sync.Mutex)))
+
+	s.Unlock("t2")
+	lock, _ = s.m.Load("t2")
+	r.False(mutexLocked(lock.(*sync.Mutex)))
+}
+
+func TestKeyRWLockerLockUnlock(t *testing.T) {
+	r := require.New(t)
+	s := NewKeyRWLocker()
+
+	s.Lock("t1")
+	lock, _ := s.m.Load("t1")
+	r.True(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.False(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.Unlock("t1")
+	lock, _ = s.m.Load("t1")
+	r.False(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.False(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.Lock("t2")
+	lock, _ = s.m.Load("t2")
+	r.True(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.False(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.Unlock("t2")
+	lock, _ = s.m.Load("t2")
+	r.False(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.False(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.RLock("t1")
+	lock, _ = s.m.Load("t1")
+	r.False(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.True(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.RUnlock("t1")
+	lock, _ = s.m.Load("t1")
+	r.False(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.False(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.RLock("t2")
+	lock, _ = s.m.Load("t2")
+	r.False(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.True(rwMutexRLocked(lock.(*sync.RWMutex)))
+
+	s.RUnlock("t2")
+	lock, _ = s.m.Load("t2")
+	r.False(rwMutexLocked(lock.(*sync.RWMutex)))
+	r.False(rwMutexRLocked(lock.(*sync.RWMutex)))
+}

platform/dbops/binaries/weaviate-src/entities/tenantactivity/types.go

@@ -0,0 +1,26 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tenantactivity
+
+import "time"
+
+type ByCollection map[string]ByTenant
+
+type ByTenant map[string]time.Time
+
+type UsageFilter int
+
+const (
+	UsageFilterAll UsageFilter = iota
+	UsageFilterOnlyReads
+	UsageFilterOnlyWrites
+)

platform/dbops/binaries/weaviate-src/entities/tokenizer/tokenizer.go

@@ -0,0 +1,452 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tokenizer
+
+import (
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+	"unicode"
+
+	entcfg "github.com/weaviate/weaviate/entities/config"
+
+	"github.com/go-ego/gse"
+	koDict "github.com/ikawaha/kagome-dict-ko"
+	"github.com/ikawaha/kagome-dict/ipa"
+	kagomeTokenizer "github.com/ikawaha/kagome/v2/tokenizer"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+)
+
+var (
+	gseTokenizer    *gse.Segmenter  // Japanese
+	gseTokenizerCh  *gse.Segmenter  // Chinese
+	gseLock         = &sync.Mutex{} // Lock for gse
+	UseGse          = false         // Load Japanese dictionary and prepare tokenizer
+	UseGseCh        = false         // Load Chinese dictionary and prepare tokenizer
+	KagomeKrEnabled = false         // Load Korean dictionary and prepare tokenizer
+	KagomeJaEnabled = false         // Load Japanese dictionary and prepare tokenizer
+	// The Tokenizer Libraries can consume a lot of memory, so we limit the number of parallel tokenizers
+	ApacTokenizerThrottle = chan struct{}(nil) // Throttle for tokenizers
+	tokenizers            KagomeTokenizers     // Tokenizers for Korean and Japanese
+	kagomeInitLock        sync.Mutex           // Lock for kagome initialization
+)
+
+type KagomeTokenizers struct {
+	Korean   *kagomeTokenizer.Tokenizer
+	Japanese *kagomeTokenizer.Tokenizer
+}
+
+// Optional tokenizers can be enabled with an environment variable like:
+// 'ENABLE_TOKENIZER_XXX', e.g. 'ENABLE_TOKENIZER_GSE', 'ENABLE_TOKENIZER_KAGOME_KR', 'ENABLE_TOKENIZER_KAGOME_JA'
+var Tokenizations []string = []string{
+	models.PropertyTokenizationWord,
+	models.PropertyTokenizationLowercase,
+	models.PropertyTokenizationWhitespace,
+	models.PropertyTokenizationField,
+	models.PropertyTokenizationTrigram,
+}
+
+func init() {
+	numParallel := runtime.GOMAXPROCS(0)
+	numParallelStr := os.Getenv("TOKENIZER_CONCURRENCY_COUNT")
+	if numParallelStr != "" {
+		x, err := strconv.Atoi(numParallelStr)
+		if err == nil {
+			numParallel = x
+		}
+	}
+	ApacTokenizerThrottle = make(chan struct{}, numParallel)
+	if entcfg.Enabled(os.Getenv("USE_GSE")) || entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_GSE")) {
+		UseGse = true
+		Tokenizations = append(Tokenizations, models.PropertyTokenizationGse)
+		init_gse()
+	}
+	if entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_GSE_CH")) {
+		Tokenizations = append(Tokenizations, models.PropertyTokenizationGseCh)
+		UseGseCh = true
+		init_gse_ch()
+	}
+	if entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_KAGOME_KR")) {
+		Tokenizations = append(Tokenizations, models.PropertyTokenizationKagomeKr)
+	}
+	if entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_KAGOME_JA")) {
+		Tokenizations = append(Tokenizations, models.PropertyTokenizationKagomeJa)
+	}
+	_ = initializeKagomeTokenizerKr()
+	_ = initializeKagomeTokenizerJa()
+}
+
+func init_gse() {
+	gseLock.Lock()
+	defer gseLock.Unlock()
+	if gseTokenizer == nil {
+		startTime := time.Now()
+		seg, err := gse.New("ja")
+		if err != nil {
+			return
+		}
+		gseTokenizer = &seg
+		monitoring.GetMetrics().TokenizerInitializeDuration.WithLabelValues("gse").Observe(time.Since(startTime).Seconds())
+	}
+}
+
+func init_gse_ch() {
+	gseLock.Lock()
+	defer gseLock.Unlock()
+	if gseTokenizerCh == nil {
+		startTime := time.Now()
+		seg, err := gse.New("zh")
+		if err != nil {
+			return
+		}
+		gseTokenizerCh = &seg
+		monitoring.GetMetrics().TokenizerInitializeDuration.WithLabelValues("gse").Observe(time.Since(startTime).Seconds())
+	}
+}
+
+func Tokenize(tokenization string, in string) []string {
+	switch tokenization {
+	case models.PropertyTokenizationWord:
+		return tokenizeWord(in)
+	case models.PropertyTokenizationLowercase:
+		return tokenizeLowercase(in)
+	case models.PropertyTokenizationWhitespace:
+		return tokenizeWhitespace(in)
+	case models.PropertyTokenizationField:
+		return tokenizeField(in)
+	case models.PropertyTokenizationTrigram:
+		return tokenizetrigram(in)
+	case models.PropertyTokenizationGse:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeGSE(in)
+	case models.PropertyTokenizationGseCh:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeGseCh(in)
+	case models.PropertyTokenizationKagomeKr:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeKagomeKr(in)
+	case models.PropertyTokenizationKagomeJa:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeKagomeJa(in)
+	default:
+		return []string{}
+	}
+}
+
+func TokenizeWithWildcards(tokenization string, in string) []string {
+	switch tokenization {
+	case models.PropertyTokenizationWord:
+		return tokenizeWordWithWildcards(in)
+	case models.PropertyTokenizationLowercase:
+		return tokenizeLowercase(in)
+	case models.PropertyTokenizationWhitespace:
+		return tokenizeWhitespace(in)
+	case models.PropertyTokenizationField:
+		return tokenizeField(in)
+	case models.PropertyTokenizationTrigram:
+		return tokenizetrigramWithWildcards(in)
+	case models.PropertyTokenizationGse:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeGSE(in)
+	case models.PropertyTokenizationGseCh:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeGseCh(in)
+	case models.PropertyTokenizationKagomeKr:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeKagomeKr(in)
+	case models.PropertyTokenizationKagomeJa:
+		ApacTokenizerThrottle <- struct{}{}
+		defer func() { <-ApacTokenizerThrottle }()
+		return tokenizeKagomeJa(in)
+	default:
+		return []string{}
+	}
+}
+
+func removeEmptyStrings(terms []string) []string {
+	for i := 0; i < len(terms); i++ {
+		if terms[i] == "" || terms[i] == " " {
+			terms = append(terms[:i], terms[i+1:]...)
+			i--
+		}
+	}
+	return terms
+}
+
+// tokenizeField trims white spaces
+// (former DataTypeString/Field)
+func tokenizeField(in string) []string {
+	startTime := time.Now()
+	ret := []string{strings.TrimFunc(in, unicode.IsSpace)}
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("field").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("field").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("field").Observe(float64(len(ret)))
+	return ret
+}
+
+// tokenizeWhitespace splits on white spaces, does not alter casing
+// (former DataTypeString/Word)
+func tokenizeWhitespace(in string) []string {
+	startTime := time.Now()
+	ret := strings.FieldsFunc(in, unicode.IsSpace)
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("whitespace").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("whitespace").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("whitespace").Observe(float64(len(ret)))
+	return ret
+}
+
+// tokenizeLowercase splits on white spaces and lowercases the words
+func tokenizeLowercase(in string) []string {
+	startTime := time.Now()
+	terms := tokenizeWhitespace(in)
+	ret := lowercase(terms)
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("lowercase").Observe(float64(time.Since(startTime).Seconds()))
+	return ret
+}
+
+// tokenizeWord splits on any non-alphanumerical and lowercases the words
+// (former DataTypeText/Word)
+func tokenizeWord(in string) []string {
+	startTime := time.Now()
+	terms := strings.FieldsFunc(in, func(r rune) bool {
+		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
+	})
+	ret := lowercase(terms)
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("word").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("word").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("word").Observe(float64(len(ret)))
+	return ret
+}
+
+// tokenizetrigram splits on any non-alphanumerical and lowercases the words, joins them together, then groups them into trigrams
+func tokenizetrigram(in string) []string {
+	startTime := time.Now()
+	// Strip whitespace and punctuation from the input string
+	inputString := strings.ToLower(strings.Join(strings.FieldsFunc(in, func(r rune) bool {
+		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
+	}), ""))
+	runes := []rune(inputString)
+	var trirunes [][]rune
+	for i := 0; i < len(runes)-2; i++ {
+		trirunes = append(trirunes, runes[i:i+3])
+	}
+
+	var trigrams []string
+	for _, trirune := range trirunes {
+		trigrams = append(trigrams, string(trirune))
+	}
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("trigram").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("trigram").Add(float64(len(trigrams)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("trigram").Observe(float64(len(trigrams)))
+	return trigrams
+}
+
+// tokenizeGSE uses the gse tokenizer to tokenise Japanese
+func tokenizeGSE(in string) []string {
+	if !UseGse {
+		return []string{}
+	}
+	startTime := time.Now()
+	gseLock.Lock()
+	defer gseLock.Unlock()
+	terms := gseTokenizer.CutAll(in)
+
+	ret := removeEmptyStrings(terms)
+
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("gse").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("gse").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("gse").Observe(float64(len(ret)))
+	return ret
+}
+
+// tokenizeGSE uses the gse tokenizer to tokenise Chinese
+func tokenizeGseCh(in string) []string {
+	if !UseGseCh {
+		return []string{}
+	}
+	gseLock.Lock()
+	defer gseLock.Unlock()
+	startTime := time.Now()
+	terms := gseTokenizerCh.CutAll(in)
+	ret := removeEmptyStrings(terms)
+
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("gse").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("gse").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("gse").Observe(float64(len(ret)))
+	return ret
+}
+
+func initializeKagomeTokenizerKr() error {
+	// Acquire lock to prevent initialization race
+	kagomeInitLock.Lock()
+	defer kagomeInitLock.Unlock()
+
+	if entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_KAGOME_KR")) {
+		if tokenizers.Korean != nil {
+			return nil
+		}
+		startTime := time.Now()
+
+		dictInstance := koDict.Dict()
+		tokenizer, err := kagomeTokenizer.New(dictInstance)
+		if err != nil {
+			return err
+		}
+
+		tokenizers.Korean = tokenizer
+		KagomeKrEnabled = true
+		monitoring.GetMetrics().TokenizerInitializeDuration.WithLabelValues("kagome_kr").Observe(float64(time.Since(startTime).Seconds()))
+		return nil
+	}
+
+	return nil
+}
+
+func tokenizeKagomeKr(in string) []string {
+	tokenizer := tokenizers.Korean
+	if tokenizer == nil || !KagomeKrEnabled {
+		return []string{}
+	}
+	startTime := time.Now()
+
+	kagomeTokens := tokenizer.Tokenize(in)
+	terms := make([]string, 0, len(kagomeTokens))
+
+	for _, token := range kagomeTokens {
+		if token.Surface != "EOS" && token.Surface != "BOS" {
+			terms = append(terms, token.Surface)
+		}
+	}
+
+	ret := removeEmptyStrings(terms)
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("kagome_kr").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("kagome_kr").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("kagome_kr").Observe(float64(len(ret)))
+	return ret
+}
+
+func initializeKagomeTokenizerJa() error {
+	// Acquire lock to prevent initialization race
+	kagomeInitLock.Lock()
+	defer kagomeInitLock.Unlock()
+
+	if entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_KAGOME_JA")) {
+		if tokenizers.Japanese != nil {
+			return nil
+		}
+		startTime := time.Now()
+		dictInstance := ipa.Dict()
+		tokenizer, err := kagomeTokenizer.New(dictInstance)
+		if err != nil {
+			return err
+		}
+
+		tokenizers.Japanese = tokenizer
+		KagomeJaEnabled = true
+		monitoring.GetMetrics().TokenizerInitializeDuration.WithLabelValues("kagome_ja").Observe(float64(time.Since(startTime).Seconds()))
+		return nil
+	}
+
+	return nil
+}
+
+func tokenizeKagomeJa(in string) []string {
+	tokenizer := tokenizers.Japanese
+	if tokenizer == nil || !KagomeJaEnabled {
+		return []string{}
+	}
+
+	startTime := time.Now()
+	kagomeTokens := tokenizer.Analyze(in, kagomeTokenizer.Search)
+	terms := make([]string, 0, len(kagomeTokens))
+
+	for _, token := range kagomeTokens {
+		if token.Surface != "EOS" && token.Surface != "BOS" {
+			terms = append(terms, strings.ToLower(token.Surface))
+		}
+	}
+
+	ret := removeEmptyStrings(terms)
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("kagome_ja").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("kagome_ja").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("kagome_ja").Observe(float64(len(ret)))
+	return ret
+}
+
+// tokenizeWordWithWildcards splits on any non-alphanumerical except wildcard-symbols and
+// lowercases the words
+func tokenizeWordWithWildcards(in string) []string {
+	startTime := time.Now()
+	terms := strings.FieldsFunc(in, func(r rune) bool {
+		return !unicode.IsLetter(r) && !unicode.IsNumber(r) && r != '?' && r != '*'
+	})
+	ret := lowercase(terms)
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("word_with_wildcards").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("word_with_wildcards").Add(float64(len(ret)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("word_with_wildcards").Observe(float64(len(ret)))
+	return ret
+}
+
+// tokenizetrigramWithWildcards splits on any non-alphanumerical and lowercases the words, applies any wildcards, then joins them together, then groups them into trigrams
+// this is unlikely to be useful, but is included for completeness
+func tokenizetrigramWithWildcards(in string) []string {
+	startTime := time.Now()
+	terms := tokenizeWordWithWildcards(in)
+	inputString := strings.Join(terms, "")
+	var trigrams []string
+	for i := 0; i < len(inputString)-2; i++ {
+		trigrams = append(trigrams, inputString[i:i+3])
+	}
+	monitoring.GetMetrics().TokenizerDuration.WithLabelValues("trigram_with_wildcards").Observe(float64(time.Since(startTime).Seconds()))
+	monitoring.GetMetrics().TokenCount.WithLabelValues("trigram_with_wildcards").Add(float64(len(trigrams)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("trigram_with_wildcards").Observe(float64(len(trigrams)))
+	return trigrams
+}
+
+func lowercase(terms []string) []string {
+	for i := range terms {
+		terms[i] = strings.ToLower(terms[i])
+	}
+	monitoring.GetMetrics().TokenCount.WithLabelValues("lowercase").Add(float64(len(terms)))
+	monitoring.GetMetrics().TokenCountPerRequest.WithLabelValues("lowercase").Observe(float64(len(terms)))
+	return terms
+}
+
+func TokenizeAndCountDuplicates(tokenization string, in string) ([]string, []int) {
+	counts := map[string]int{}
+	for _, term := range Tokenize(tokenization, in) {
+		counts[term]++
+	}
+
+	unique := make([]string, len(counts))
+	boosts := make([]int, len(counts))
+
+	i := 0
+	for term, boost := range counts {
+		unique[i] = term
+		boosts[i] = boost
+		i++
+	}
+
+	return unique, boosts
+}

platform/dbops/binaries/weaviate-src/entities/tokenizer/tokenizer_test.go

@@ -0,0 +1,267 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tokenizer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func TestTokeniseParallel(t *testing.T) {
+	UseGse = true
+	init_gse()
+	UseGseCh = true
+	init_gse_ch()
+	// Kagome tokenizer for Korean
+	t.Setenv("ENABLE_TOKENIZER_KAGOME_KR", "true")
+	_ = initializeKagomeTokenizerKr()
+
+	// Kagome tokenizer for Japanese
+	t.Setenv("ENABLE_TOKENIZER_KAGOME_JA", "true")
+	_ = initializeKagomeTokenizerJa()
+	for i := 0; i < 1000; i++ {
+		go SingleTokenise(t)
+	}
+}
+
+func SingleTokenise(t *testing.T) {
+	tokens := Tokenize(models.PropertyTokenizationTrigram, "Thequickbrownfoxjumpsoverthelazydog")
+	assert.Equal(t, []string{"the", "heq", "equ", "qui", "uic", "ick", "ckb", "kbr", "bro", "row", "own", "wnf", "nfo", "fox", "oxj", "xju", "jum", "ump", "mps", "pso", "sov", "ove", "ver", "ert", "rth", "the", "hel", "ela", "laz", "azy", "zyd", "ydo", "dog"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationTrigram, "The quick brown fox jumps over the lazy dog")
+	assert.Equal(t, []string{"the", "heq", "equ", "qui", "uic", "ick", "ckb", "kbr", "bro", "row", "own", "wnf", "nfo", "fox", "oxj", "xju", "jum", "ump", "mps", "pso", "sov", "ove", "ver", "ert", "rth", "the", "hel", "ela", "laz", "azy", "zyd", "ydo", "dog"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationTrigram, "いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす")
+	assert.Equal(t, []string{"いろは", "ろはに", "はにほ", "にほへ", "ほへと", "へとち", "とちり", "ちりぬ", "りぬる", "ぬるを", "るをわ", "をわか", "わかよ", "かよた", "よたれ", "たれそ", "れそつ", "そつね", "つねな", "ねなら", "ならむ", "らむう", "むうゐ", "うゐの", "ゐのお", "のおく", "おくや", "くやま", "やまけ", "まけふ", "けふこ", "ふこえ", "こえて", "えてあ", "てあさ", "あさき", "さきゆ", "きゆめ", "ゆめみ", "めみし", "みしゑ", "しゑひ", "ゑひも", "ひもせ", "もせす"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationTrigram, `春の夜の夢はうつつよりもかなしき
+	夏の夜の夢はうつつに似たり
+	秋の夜の夢はうつつを超え
+	冬の夜の夢は心に響く
+
+	山のあなたに小さな村が見える
+	川の音が静かに耳に届く
+	風が木々を通り抜ける音
+	星空の下、すべてが平和である`)
+	assert.Equal(t, []string{"春の夜", "の夜の", "夜の夢", "の夢は", "夢はう", "はうつ", "うつつ", "つつよ", "つより", "よりも", "りもか", "もかな", "かなし", "なしき", "しき夏", "き夏の", "夏の夜", "の夜の", "夜の夢", "の夢は", "夢はう", "はうつ", "うつつ", "つつに", "つに似", "に似た", "似たり", "たり秋", "り秋の", "秋の夜", "の夜の", "夜の夢", "の夢は", "夢はう", "はうつ", "うつつ", "つつを", "つを超", "を超え", "超え冬", "え冬の", "冬の夜", "の夜の", "夜の夢", "の夢は", "夢は心", "は心に", "心に響", "に響く", "響く山", "く山の", "山のあ", "のあな", "あなた", "なたに", "たに小", "に小さ", "小さな", "さな村", "な村が", "村が見", "が見え", "見える", "える川", "る川の", "川の音", "の音が", "音が静", "が静か", "静かに", "かに耳", "に耳に", "耳に届", "に届く", "届く風", "く風が", "風が木", "が木々", "木々を", "々を通", "を通り", "通り抜", "り抜け", "抜ける", "ける音", "る音星", "音星空", "星空の", "空の下", "の下す", "下すべ", "すべて", "べてが", "てが平", "が平和", "平和で", "和であ", "である"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationGse, `春の夜の夢はうつつよりもかなしき
+	夏の夜の夢はうつつに似たり
+	秋の夜の夢はうつつを超え
+	冬の夜の夢は心に響く
+
+	山のあなたに小さな村が見える
+	川の音が静かに耳に届く
+	風が木々を通り抜ける音
+	星空の下、すべてが平和である`)
+	assert.Equal(t, []string{"春の", "夜", "の", "夢", "はう", "うつ", "うつつ", "つつ", "つよ", "より", "も", "かな", "かなし", "かなしき", "なし", "しき", "\n", "\t", "夏", "の", "夜", "の", "夢", "はう", "うつ", "うつつ", "つつ", "に", "似", "たり", "\n", "\t", "秋", "の", "夜", "の", "夢", "はう", "うつ", "うつつ", "つつ", "を", "超え", "\n", "\t", "冬", "の", "夜", "の", "夢", "は", "心", "に", "響く", "\n", "\n", "\t", "山", "の", "あな", "あなた", "に", "小さ", "小さな", "村", "が", "見え", "見える", "える", "\n", "\t", "川", "の", "音", "が", "静か", "かに", "耳", "に", "届く", "\n", "\t", "風", "が", "木々", "を", "通り", "通り抜け", "通り抜ける", "抜け", "抜ける", "ける", "音", "\n", "\t", "星空", "の", "下", "、", "すべ", "すべて", "が", "平和", "で", "ある"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationGse, "素早い茶色の狐が怠けた犬を飛び越えた")
+	assert.Equal(t, []string{"素早", "素早い", "早い", "茶色", "の", "狐", "が", "怠け", "けた", "犬", "を", "飛び", "飛び越え", "越え", "た"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationGse, "すばやいちゃいろのきつねがなまけたいぬをとびこえた")
+	assert.Equal(t, []string{"すばや", "すばやい", "やい", "いち", "ちゃ", "ちゃい", "ちゃいろ", "いろ", "のき", "きつ", "きつね", "つね", "ねが", "がな", "なま", "なまけ", "まけ", "けた", "けたい", "たい", "いぬ", "を", "とび", "とびこえ", "こえ", "た"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationGse, "スバヤイチャイロノキツネガナマケタイヌヲトビコエタ")
+	assert.Equal(t, []string{"スバ", "ヤイ", "イチ", "チャイ", "チャイロ", "ノ", "キツ", "キツネ", "ツネ", "ネガ", "ナマ", "ケタ", "タイ", "イヌ", "ヲ", "トビ", "コ", "エ", "タ"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationGse, "The quick brown fox jumps over the lazy dog")
+	assert.Equal(t, []string{"t", "h", "e", "q", "u", "i", "c", "k", "b", "r", "o", "w", "n", "f", "o", "x", "j", "u", "m", "p", "s", "o", "v", "e", "r", "t", "h", "e", "l", "a", "z", "y", "d", "o", "g"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationGseCh, "施氏食狮史石室诗士施氏，嗜狮，誓食十狮。氏时时适市视狮。十时，适十狮适市。是时，适施氏适市。氏视是十狮，恃矢势，使是十狮逝世。氏拾是十狮尸，适石室。石室湿，氏使侍拭石室。石室拭，氏始试食是十狮尸。食时，始识是十狮尸，实十石狮尸。试释是事。")
+	assert.Equal(t, []string{"施", "氏", "食", "狮", "史", "石室", "诗", "士", "施", "氏", "，", "嗜", "狮", "，", "誓", "食", "十", "狮", "。", "氏", "时时", "适", "市", "视", "狮", "。", "十时", "，", "适", "十", "狮", "适", "市", "。", "是", "时", "，", "适", "施", "氏", "适", "市", "。", "氏", "视", "是", "十", "狮", "，", "恃", "矢", "势", "，", "使", "是", "十", "狮", "逝世", "。", "氏", "拾", "是", "十", "狮", "尸", "，", "适", "石室", "。", "石室", "湿", "，", "氏", "使", "侍", "拭", "石室", "。", "石室", "拭", "，", "氏", "始", "试", "食", "是", "十", "狮", "尸", "。", "食", "时", "，", "始", "识", "是", "十", "狮", "尸", "，", "实", "十", "石狮", "尸", "。", "试", "释", "是", "事", "。"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeKr, "아버지가방에들어가신다")
+	assert.Equal(t, []string{"아버지", "가", "방", "에", "들어가", "신다"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeKr, "아버지가 방에 들어가신다")
+	assert.Equal(t, []string{"아버지", "가", "방", "에", "들어가", "신다"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeKr, "결정하겠다")
+	assert.Equal(t, []string{"결정", "하", "겠", "다"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeKr, "한국어를처리하는예시입니다")
+	assert.Equal(t, []string{"한국어", "를", "처리", "하", "는", "예시", "입니다"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeKr, "한국어를 처리하는 예시입니다")
+	assert.Equal(t, []string{"한국어", "를", "처리", "하", "는", "예시", "입니다"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeJa, `春の夜の夢はうつつよりもかなしき
+	夏の夜の夢はうつつに似たり
+	秋の夜の夢はうつつを超え
+	冬の夜の夢は心に響く
+
+	山のあなたに小さな村が見える
+	川の音が静かに耳に届く
+	風が木々を通り抜ける音
+	星空の下、すべてが平和である`)
+	assert.Equal(t, []string{"春", "の", "夜", "の", "夢", "は", "うつつ", "より", "も", "かなしき", "\n\t", "夏", "の", "夜", "の", "夢", "は", "うつつ", "に", "似", "たり", "\n\t", "秋", "の", "夜", "の", "夢", "は", "うつつ", "を", "超え", "\n\t", "冬", "の", "夜", "の", "夢", "は", "心", "に", "響く", "\n\n\t", "山", "の", "あなた", "に", "小さな", "村", "が", "見える", "\n\t", "川", "の", "音", "が", "静か", "に", "耳", "に", "届く", "\n\t", "風", "が", "木々", "を", "通り抜ける", "音", "\n\t", "星空", "の", "下", "、", "すべて", "が", "平和", "で", "ある"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeJa, "素早い茶色の狐が怠けた犬を飛び越えた")
+	assert.Equal(t, []string{"素早い", "茶色", "の", "狐", "が", "怠け", "た", "犬", "を", "飛び越え", "た"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeJa, "すばやいちゃいろのきつねがなまけたいぬをとびこえた")
+	assert.Equal(t, []string{"すばやい", "ちゃ", "いろ", "の", "きつね", "が", "なまけ", "た", "いぬ", "を", "とびこえ", "た"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeJa, "スバヤイチャイロノキツネガナマケタイヌヲトビコエタ")
+	assert.Equal(t, []string{"スバ", "ヤイ", "チャイ", "ロノキツネガナマケタイヌヲトビコエタ"}, tokens)
+
+	tokens = Tokenize(models.PropertyTokenizationKagomeJa, "The quick brown fox jumps over the lazy dog")
+	assert.Equal(t, []string{"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"}, tokens)
+}
+
+func TestTokenize(t *testing.T) {
+	input := " Hello You*-beautiful_world?!"
+
+	type testCase struct {
+		tokenization string
+		expected     []string
+	}
+
+	t.Run("tokenize", func(t *testing.T) {
+		testCases := []testCase{
+			{
+				tokenization: models.PropertyTokenizationField,
+				expected:     []string{"Hello You*-beautiful_world?!"},
+			},
+			{
+				tokenization: models.PropertyTokenizationWhitespace,
+				expected:     []string{"Hello", "You*-beautiful_world?!"},
+			},
+			{
+				tokenization: models.PropertyTokenizationLowercase,
+				expected:     []string{"hello", "you*-beautiful_world?!"},
+			},
+			{
+				tokenization: models.PropertyTokenizationWord,
+				expected:     []string{"hello", "you", "beautiful", "world"},
+			},
+		}
+
+		for _, tc := range testCases {
+			terms := Tokenize(tc.tokenization, input)
+			assert.ElementsMatch(t, tc.expected, terms)
+		}
+	})
+
+	t.Run("tokenize with wildcards", func(t *testing.T) {
+		testCases := []testCase{
+			{
+				tokenization: models.PropertyTokenizationField,
+				expected:     []string{"Hello You*-beautiful_world?!"},
+			},
+			{
+				tokenization: models.PropertyTokenizationWhitespace,
+				expected:     []string{"Hello", "You*-beautiful_world?!"},
+			},
+			{
+				tokenization: models.PropertyTokenizationLowercase,
+				expected:     []string{"hello", "you*-beautiful_world?!"},
+			},
+			{
+				tokenization: models.PropertyTokenizationWord,
+				expected:     []string{"hello", "you*", "beautiful", "world?"},
+			},
+		}
+
+		for _, tc := range testCases {
+			terms := TokenizeWithWildcards(tc.tokenization, input)
+			assert.ElementsMatch(t, tc.expected, terms)
+		}
+	})
+}
+
+func TestTokenizeAndCountDuplicates(t *testing.T) {
+	type testCase struct {
+		input        string
+		tokenization string
+		expected     map[string]int
+	}
+
+	t.Setenv("ENABLE_TOKENIZER_KAGOME_KR", "true")
+	_ = initializeKagomeTokenizerKr()
+
+	alphaInput := "Hello You Beautiful World! hello you beautiful world!"
+
+	testCases := []testCase{
+		{
+			input:        alphaInput,
+			tokenization: models.PropertyTokenizationField,
+			expected: map[string]int{
+				"Hello You Beautiful World! hello you beautiful world!": 1,
+			},
+		},
+		{
+			input:        alphaInput,
+			tokenization: models.PropertyTokenizationWhitespace,
+			expected: map[string]int{
+				"Hello":     1,
+				"You":       1,
+				"Beautiful": 1,
+				"World!":    1,
+				"hello":     1,
+				"you":       1,
+				"beautiful": 1,
+				"world!":    1,
+			},
+		},
+		{
+			input:        alphaInput,
+			tokenization: models.PropertyTokenizationLowercase,
+			expected: map[string]int{
+				"hello":     2,
+				"you":       2,
+				"beautiful": 2,
+				"world!":    2,
+			},
+		},
+		{
+			input:        alphaInput,
+			tokenization: models.PropertyTokenizationWord,
+			expected: map[string]int{
+				"hello":     2,
+				"you":       2,
+				"beautiful": 2,
+				"world":     2,
+			},
+		},
+		{
+			input:        "한국어를 처리하는 예시입니다 한국어를 처리하는 예시입니다",
+			tokenization: models.PropertyTokenizationKagomeKr,
+			expected: map[string]int{
+				"한국어": 2,
+				"를":   2,
+				"처리":  2,
+				"하":   2,
+				"는":   2,
+				"예시":  2,
+				"입니다": 2,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.tokenization, func(t *testing.T) {
+			terms, dups := TokenizeAndCountDuplicates(tc.tokenization, tc.input)
+
+			assert.Len(t, terms, len(tc.expected))
+			assert.Len(t, dups, len(tc.expected))
+
+			for i := range terms {
+				assert.Contains(t, tc.expected, terms[i])
+				assert.Equal(t, tc.expected[terms[i]], dups[i])
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/common/config.go

@@ -0,0 +1,110 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package common
+
+import (
+	"encoding/json"
+	"math"
+	"strconv"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	DistanceCosine    = "cosine"
+	DistanceDot       = "dot"
+	DistanceL2Squared = "l2-squared"
+	DistanceManhattan = "manhattan"
+	DistanceHamming   = "hamming"
+
+	// Set these defaults if the user leaves them blank
+	DefaultVectorCacheMaxObjects = 1e12
+	DefaultDistanceMetric        = DistanceCosine
+)
+
+const (
+	CompressionBQ = "bq"
+	CompressionPQ = "pq"
+	CompressionSQ = "sq"
+	CompressionRQ = "rq"
+	NoCompression = "none"
+)
+
+// Tries to parse the int value from the map, if it overflows math.MaxInt64, it
+// uses math.MaxInt64 instead. This is to protect from rounding errors from
+// json marshalling where the type may be assumed as float64
+func OptionalIntFromMap(in map[string]interface{}, name string,
+	setFn func(v int),
+) error {
+	value, ok := in[name]
+	if !ok {
+		return nil
+	}
+
+	var asInt64 int64
+	var err error
+
+	// depending on whether we get the results from disk or from the REST API,
+	// numbers may be represented slightly differently
+	switch typed := value.(type) {
+	case json.Number:
+		asInt64, err = typed.Int64()
+	case float64:
+		asInt64 = int64(typed)
+	}
+	if err != nil {
+		// try to recover from error
+		if errors.Is(err, strconv.ErrRange) {
+			setFn(int(math.MaxInt64))
+			return nil
+		}
+
+		return errors.Wrapf(err, "json.Number to int64 for %q", name)
+	}
+
+	setFn(int(asInt64))
+	return nil
+}
+
+func OptionalBoolFromMap(in map[string]interface{}, name string,
+	setFn func(v bool),
+) error {
+	value, ok := in[name]
+	if !ok {
+		return nil
+	}
+
+	asBool, ok := value.(bool)
+	if !ok {
+		return nil
+	}
+
+	setFn(asBool)
+	return nil
+}
+
+func OptionalStringFromMap(in map[string]interface{}, name string,
+	setFn func(v string),
+) error {
+	value, ok := in[name]
+	if !ok {
+		return nil
+	}
+
+	asString, ok := value.(string)
+	if !ok {
+		return nil
+	}
+
+	setFn(asString)
+	return nil
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/config.go

@@ -0,0 +1,47 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package vectorindex
+
+import (
+	"fmt"
+
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex/dynamic"
+	"github.com/weaviate/weaviate/entities/vectorindex/flat"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+)
+
+const (
+	DefaultVectorIndexType = VectorIndexTypeHNSW
+	VectorIndexTypeHNSW    = "hnsw"
+	VectorIndexTypeFLAT    = "flat"
+	VectorIndexTypeDYNAMIC = "dynamic"
+)
+
+// ParseAndValidateConfig from an unknown input value, as this is not further
+// specified in the API to allow of exchanging the index type
+func ParseAndValidateConfig(input interface{}, vectorIndexType string, isMultiVector bool) (schemaConfig.VectorIndexConfig, error) {
+	if len(vectorIndexType) == 0 {
+		vectorIndexType = DefaultVectorIndexType
+	}
+
+	switch vectorIndexType {
+	case VectorIndexTypeHNSW:
+		return hnsw.ParseAndValidateConfig(input, isMultiVector)
+	case VectorIndexTypeFLAT:
+		return flat.ParseAndValidateConfig(input)
+	case VectorIndexTypeDYNAMIC:
+		return dynamic.ParseAndValidateConfig(input, isMultiVector)
+	default:
+		return nil, fmt.Errorf("invalid vector index %q. Supported types are hnsw and flat", vectorIndexType)
+	}
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/dynamic/config.go

@@ -0,0 +1,124 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package dynamic
+
+import (
+	"fmt"
+
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+	"github.com/weaviate/weaviate/entities/vectorindex/flat"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+)
+
+const (
+	DefaultThreshold = 10_000
+)
+
+type UserConfig struct {
+	Distance  string          `json:"distance"`
+	Threshold uint64          `json:"threshold"`
+	HnswUC    hnsw.UserConfig `json:"hnsw"`
+	FlatUC    flat.UserConfig `json:"flat"`
+}
+
+// IndexType returns the type of the underlying vector index, thus making sure
+// the schema.VectorIndexConfig interface is implemented
+func (u UserConfig) IndexType() string {
+	return "dynamic"
+}
+
+func (u UserConfig) DistanceName() string {
+	return u.Distance
+}
+
+func (u UserConfig) IsMultiVector() bool {
+	return false
+}
+
+// SetDefaults in the user-specifyable part of the config
+func (u *UserConfig) SetDefaults() {
+	u.Threshold = DefaultThreshold
+	u.Distance = common.DefaultDistanceMetric
+	u.HnswUC = hnsw.NewDefaultUserConfig()
+	u.FlatUC = flat.NewDefaultUserConfig()
+}
+
+func NewDefaultUserConfig() UserConfig {
+	uc := UserConfig{}
+	uc.SetDefaults()
+	return uc
+}
+
+// ParseAndValidateConfig from an unknown input value, as this is not further
+// specified in the API to allow of exchanging the index type
+func ParseAndValidateConfig(input interface{}, isMultiVector bool) (schemaConfig.VectorIndexConfig, error) {
+	uc := UserConfig{}
+	uc.SetDefaults()
+
+	if input == nil {
+		return uc, nil
+	}
+
+	asMap, ok := input.(map[string]interface{})
+	if !ok || asMap == nil {
+		return uc, fmt.Errorf("input must be a non-nil map")
+	}
+
+	if err := common.OptionalStringFromMap(asMap, "distance", func(v string) {
+		uc.Distance = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := common.OptionalIntFromMap(asMap, "threshold", func(v int) {
+		uc.Threshold = uint64(v)
+	}); err != nil {
+		return uc, err
+	}
+
+	hnswConfig, ok := asMap["hnsw"]
+	if ok && hnswConfig != nil {
+		hnswUC, err := hnsw.ParseAndValidateConfig(hnswConfig, isMultiVector)
+		if err != nil {
+			return uc, err
+		}
+
+		castedHnswUC, ok := hnswUC.(hnsw.UserConfig)
+		if !ok {
+			return uc, fmt.Errorf("invalid hnsw configuration")
+		}
+		uc.HnswUC = castedHnswUC
+		if uc.HnswUC.Multivector.Enabled {
+			return uc, fmt.Errorf("multi vector index is not supported for dynamic index")
+		}
+
+	}
+
+	flatConfig, ok := asMap["flat"]
+	if !ok || flatConfig == nil {
+		return uc, nil
+	}
+
+	flatUC, err := flat.ParseAndValidateConfig(flatConfig)
+	if err != nil {
+		return uc, err
+	}
+
+	castedFlatUC, ok := flatUC.(flat.UserConfig)
+	if !ok {
+		return uc, fmt.Errorf("invalid flat configuration")
+	}
+	uc.FlatUC = castedFlatUC
+
+	return uc, nil
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/dynamic/config_test.go

@@ -0,0 +1,395 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package dynamic
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+	"github.com/weaviate/weaviate/entities/vectorindex/flat"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+)
+
+func Test_DynamicUserConfig(t *testing.T) {
+	type test struct {
+		name         string
+		input        interface{}
+		expected     UserConfig
+		expectErr    bool
+		expectErrMsg string
+	}
+
+	tests := []test{
+		{
+			name:  "nothing specified, all defaults",
+			input: nil,
+			expected: UserConfig{
+				Distance:  common.DefaultDistanceMetric,
+				Threshold: DefaultThreshold,
+				HnswUC: hnsw.UserConfig{
+					CleanupIntervalSeconds: hnsw.DefaultCleanupIntervalSeconds,
+					MaxConnections:         hnsw.DefaultMaxConnections,
+					EFConstruction:         hnsw.DefaultEFConstruction,
+					VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+					EF:                     hnsw.DefaultEF,
+					Skip:                   hnsw.DefaultSkip,
+					FlatSearchCutoff:       hnsw.DefaultFlatSearchCutoff,
+					DynamicEFMin:           hnsw.DefaultDynamicEFMin,
+					DynamicEFMax:           hnsw.DefaultDynamicEFMax,
+					DynamicEFFactor:        hnsw.DefaultDynamicEFFactor,
+					Distance:               common.DefaultDistanceMetric,
+					PQ: hnsw.PQConfig{
+						Enabled:       hnsw.DefaultPQEnabled,
+						Segments:      hnsw.DefaultPQSegments,
+						Centroids:     hnsw.DefaultPQCentroids,
+						TrainingLimit: hnsw.DefaultPQTrainingLimit,
+						Encoder: hnsw.PQEncoder{
+							Type:         hnsw.DefaultPQEncoderType,
+							Distribution: hnsw.DefaultPQEncoderDistribution,
+						},
+					},
+					SQ: hnsw.SQConfig{
+						Enabled:       hnsw.DefaultSQEnabled,
+						TrainingLimit: hnsw.DefaultSQTrainingLimit,
+						RescoreLimit:  hnsw.DefaultSQRescoreLimit,
+					},
+					RQ: hnsw.RQConfig{
+						Enabled:      hnsw.DefaultRQEnabled,
+						Bits:         hnsw.DefaultRQBits,
+						RescoreLimit: hnsw.DefaultRQRescoreLimit,
+					},
+					FilterStrategy: hnsw.DefaultFilterStrategy,
+					Multivector: hnsw.MultivectorConfig{
+						Enabled:     hnsw.DefaultMultivectorEnabled,
+						Aggregation: hnsw.DefaultMultivectorAggregation,
+						MuveraConfig: hnsw.MuveraConfig{
+							Enabled:      hnsw.DefaultMultivectorMuveraEnabled,
+							KSim:         hnsw.DefaultMultivectorKSim,
+							DProjections: hnsw.DefaultMultivectorDProjections,
+							Repetitions:  hnsw.DefaultMultivectorRepetitions,
+						},
+					},
+				},
+				FlatUC: flat.UserConfig{
+					VectorCacheMaxObjects: common.DefaultVectorCacheMaxObjects,
+					Distance:              common.DefaultDistanceMetric,
+					PQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					BQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					SQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+				},
+			},
+		},
+		{
+			name: "threshold is properly set",
+			input: map[string]interface{}{
+				"threshold": float64(100),
+			},
+			expected: UserConfig{
+				Distance:  common.DefaultDistanceMetric,
+				Threshold: 100,
+				HnswUC: hnsw.UserConfig{
+					CleanupIntervalSeconds: hnsw.DefaultCleanupIntervalSeconds,
+					MaxConnections:         hnsw.DefaultMaxConnections,
+					EFConstruction:         hnsw.DefaultEFConstruction,
+					VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+					EF:                     hnsw.DefaultEF,
+					Skip:                   hnsw.DefaultSkip,
+					FlatSearchCutoff:       hnsw.DefaultFlatSearchCutoff,
+					DynamicEFMin:           hnsw.DefaultDynamicEFMin,
+					DynamicEFMax:           hnsw.DefaultDynamicEFMax,
+					DynamicEFFactor:        hnsw.DefaultDynamicEFFactor,
+					Distance:               common.DefaultDistanceMetric,
+					PQ: hnsw.PQConfig{
+						Enabled:       hnsw.DefaultPQEnabled,
+						Segments:      hnsw.DefaultPQSegments,
+						Centroids:     hnsw.DefaultPQCentroids,
+						TrainingLimit: hnsw.DefaultPQTrainingLimit,
+						Encoder: hnsw.PQEncoder{
+							Type:         hnsw.DefaultPQEncoderType,
+							Distribution: hnsw.DefaultPQEncoderDistribution,
+						},
+					},
+					SQ: hnsw.SQConfig{
+						Enabled:       hnsw.DefaultSQEnabled,
+						TrainingLimit: hnsw.DefaultSQTrainingLimit,
+						RescoreLimit:  hnsw.DefaultSQRescoreLimit,
+					},
+					RQ: hnsw.RQConfig{
+						Enabled:      hnsw.DefaultRQEnabled,
+						Bits:         hnsw.DefaultRQBits,
+						RescoreLimit: hnsw.DefaultRQRescoreLimit,
+					},
+					FilterStrategy: hnsw.DefaultFilterStrategy,
+					Multivector: hnsw.MultivectorConfig{
+						Enabled:     hnsw.DefaultMultivectorEnabled,
+						Aggregation: hnsw.DefaultMultivectorAggregation,
+						MuveraConfig: hnsw.MuveraConfig{
+							Enabled:      hnsw.DefaultMultivectorMuveraEnabled,
+							KSim:         hnsw.DefaultMultivectorKSim,
+							DProjections: hnsw.DefaultMultivectorDProjections,
+							Repetitions:  hnsw.DefaultMultivectorRepetitions,
+						},
+					},
+				},
+				FlatUC: flat.UserConfig{
+					VectorCacheMaxObjects: common.DefaultVectorCacheMaxObjects,
+					Distance:              common.DefaultDistanceMetric,
+					PQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					BQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					SQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+				},
+			},
+		},
+		{
+			name: "hnsw is properly set",
+			input: map[string]interface{}{
+				"hnsw": map[string]interface{}{
+					"cleanupIntervalSeconds": float64(11),
+					"maxConnections":         float64(12),
+					"efConstruction":         float64(13),
+					"vectorCacheMaxObjects":  float64(14),
+					"ef":                     float64(15),
+					"flatSearchCutoff":       float64(16),
+					"dynamicEfMin":           float64(17),
+					"dynamicEfMax":           float64(18),
+					"dynamicEfFactor":        float64(19),
+					"pq": map[string]interface{}{
+						"enabled":        true,
+						"bitCompression": false,
+						"segments":       float64(64),
+						"centroids":      float64(200),
+						"trainingLimit":  float64(100),
+						"encoder": map[string]interface{}{
+							"type": hnsw.PQEncoderTypeKMeans,
+						},
+					},
+					"filterStrategy": hnsw.FilterStrategyAcorn,
+				},
+			},
+			expected: UserConfig{
+				Distance:  common.DefaultDistanceMetric,
+				Threshold: DefaultThreshold,
+				HnswUC: hnsw.UserConfig{
+					CleanupIntervalSeconds: 11,
+					MaxConnections:         12,
+					EFConstruction:         13,
+					VectorCacheMaxObjects:  14,
+					EF:                     15,
+					FlatSearchCutoff:       16,
+					DynamicEFMin:           17,
+					DynamicEFMax:           18,
+					DynamicEFFactor:        19,
+					Distance:               common.DefaultDistanceMetric,
+					PQ: hnsw.PQConfig{
+						Enabled:       true,
+						Segments:      64,
+						Centroids:     200,
+						TrainingLimit: 100,
+						Encoder: hnsw.PQEncoder{
+							Type:         hnsw.DefaultPQEncoderType,
+							Distribution: hnsw.DefaultPQEncoderDistribution,
+						},
+					},
+					SQ: hnsw.SQConfig{
+						Enabled:       hnsw.DefaultSQEnabled,
+						TrainingLimit: hnsw.DefaultSQTrainingLimit,
+						RescoreLimit:  hnsw.DefaultSQRescoreLimit,
+					},
+					RQ: hnsw.RQConfig{
+						Enabled:      hnsw.DefaultRQEnabled,
+						Bits:         hnsw.DefaultRQBits,
+						RescoreLimit: hnsw.DefaultRQRescoreLimit,
+					},
+					FilterStrategy: hnsw.FilterStrategyAcorn,
+					Multivector: hnsw.MultivectorConfig{
+						Enabled:     hnsw.DefaultMultivectorEnabled,
+						Aggregation: hnsw.DefaultMultivectorAggregation,
+						MuveraConfig: hnsw.MuveraConfig{
+							Enabled:      hnsw.DefaultMultivectorMuveraEnabled,
+							KSim:         hnsw.DefaultMultivectorKSim,
+							DProjections: hnsw.DefaultMultivectorDProjections,
+							Repetitions:  hnsw.DefaultMultivectorRepetitions,
+						},
+					},
+				},
+				FlatUC: flat.UserConfig{
+					VectorCacheMaxObjects: common.DefaultVectorCacheMaxObjects,
+					Distance:              common.DefaultDistanceMetric,
+					PQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					BQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					SQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+				},
+			},
+		},
+		{
+			name: "dynamic index is set with multivector",
+			input: map[string]interface{}{
+				"hnsw": map[string]interface{}{
+					"multivector": map[string]interface{}{
+						"enabled": true,
+					},
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "multi vector index is not supported for dynamic index",
+		},
+		{
+			name: "flat is properly set",
+			input: map[string]interface{}{
+				"flat": map[string]interface{}{
+					"vectorCacheMaxObjects": float64(100),
+					"distance":              "cosine",
+					"bq": map[string]interface{}{
+						"enabled":      true,
+						"rescoreLimit": float64(100),
+						"cache":        true,
+					},
+				},
+			},
+			expected: UserConfig{
+				Distance:  common.DefaultDistanceMetric,
+				Threshold: DefaultThreshold,
+				HnswUC: hnsw.UserConfig{
+					CleanupIntervalSeconds: hnsw.DefaultCleanupIntervalSeconds,
+					MaxConnections:         hnsw.DefaultMaxConnections,
+					EFConstruction:         hnsw.DefaultEFConstruction,
+					VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+					EF:                     hnsw.DefaultEF,
+					Skip:                   hnsw.DefaultSkip,
+					FlatSearchCutoff:       hnsw.DefaultFlatSearchCutoff,
+					DynamicEFMin:           hnsw.DefaultDynamicEFMin,
+					DynamicEFMax:           hnsw.DefaultDynamicEFMax,
+					DynamicEFFactor:        hnsw.DefaultDynamicEFFactor,
+					Distance:               common.DefaultDistanceMetric,
+					PQ: hnsw.PQConfig{
+						Enabled:       hnsw.DefaultPQEnabled,
+						Segments:      hnsw.DefaultPQSegments,
+						Centroids:     hnsw.DefaultPQCentroids,
+						TrainingLimit: hnsw.DefaultPQTrainingLimit,
+						Encoder: hnsw.PQEncoder{
+							Type:         hnsw.DefaultPQEncoderType,
+							Distribution: hnsw.DefaultPQEncoderDistribution,
+						},
+					},
+					SQ: hnsw.SQConfig{
+						Enabled:       hnsw.DefaultSQEnabled,
+						TrainingLimit: hnsw.DefaultSQTrainingLimit,
+						RescoreLimit:  hnsw.DefaultSQRescoreLimit,
+					},
+					RQ: hnsw.RQConfig{
+						Enabled:      hnsw.DefaultRQEnabled,
+						Bits:         hnsw.DefaultRQBits,
+						RescoreLimit: hnsw.DefaultRQRescoreLimit,
+					},
+					FilterStrategy: hnsw.DefaultFilterStrategy,
+					Multivector: hnsw.MultivectorConfig{
+						Enabled:     hnsw.DefaultMultivectorEnabled,
+						Aggregation: hnsw.DefaultMultivectorAggregation,
+						MuveraConfig: hnsw.MuveraConfig{
+							Enabled:      hnsw.DefaultMultivectorMuveraEnabled,
+							KSim:         hnsw.DefaultMultivectorKSim,
+							DProjections: hnsw.DefaultMultivectorDProjections,
+							Repetitions:  hnsw.DefaultMultivectorRepetitions,
+						},
+					},
+				},
+				FlatUC: flat.UserConfig{
+					VectorCacheMaxObjects: 100,
+					Distance:              common.DefaultDistanceMetric,
+					PQ: flat.CompressionUserConfig{
+						Enabled:      false,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+					BQ: flat.CompressionUserConfig{
+						Enabled:      true,
+						RescoreLimit: 100,
+						Cache:        true,
+					},
+					SQ: flat.CompressionUserConfig{
+						Enabled:      flat.DefaultCompressionEnabled,
+						RescoreLimit: flat.DefaultCompressionRescore,
+						Cache:        flat.DefaultVectorCache,
+					},
+				},
+			},
+		},
+		{
+			name: "pq enabled with flat returns error",
+			input: map[string]interface{}{
+				"flat": map[string]interface{}{
+					"vectorCacheMaxObjects": float64(100),
+					"distance":              "cosine",
+					"pq": map[string]interface{}{
+						"enabled":      true,
+						"rescoreLimit": float64(100),
+						"cache":        true,
+					},
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "PQ is not currently supported for flat indices",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cfg, err := ParseAndValidateConfig(test.input, false)
+			if test.expectErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expectErrMsg)
+				return
+			} else {
+				assert.Nil(t, err)
+				assert.Equal(t, test.expected, cfg)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/flat/config.go

@@ -0,0 +1,190 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package flat
+
+import (
+	"errors"
+	"fmt"
+
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	vectorindexcommon "github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+const (
+	DefaultVectorCache           = false
+	DefaultVectorCacheMaxObjects = 1e12
+	DefaultCompressionEnabled    = false
+	DefaultCompressionRescore    = -1 // indicates "let Weaviate pick"
+)
+
+type CompressionUserConfig struct {
+	Enabled      bool `json:"enabled"`
+	RescoreLimit int  `json:"rescoreLimit"`
+	Cache        bool `json:"cache"`
+}
+
+type UserConfig struct {
+	Distance              string                `json:"distance"`
+	VectorCacheMaxObjects int                   `json:"vectorCacheMaxObjects"`
+	PQ                    CompressionUserConfig `json:"pq"`
+	BQ                    CompressionUserConfig `json:"bq"`
+	SQ                    CompressionUserConfig `json:"sq"`
+}
+
+// IndexType returns the type of the underlying vector index, thus making sure
+// the schema.VectorIndexConfig interface is implemented
+func (u UserConfig) IndexType() string {
+	return "flat"
+}
+
+func (u UserConfig) DistanceName() string {
+	return u.Distance
+}
+
+func (u UserConfig) IsMultiVector() bool {
+	return false
+}
+
+// SetDefaults in the user-specifyable part of the config
+func (u *UserConfig) SetDefaults() {
+	u.PQ.Cache = DefaultVectorCache
+	u.BQ.Cache = DefaultVectorCache
+	u.VectorCacheMaxObjects = DefaultVectorCacheMaxObjects
+	u.Distance = vectorindexcommon.DefaultDistanceMetric
+	u.PQ.Enabled = DefaultCompressionEnabled
+	u.PQ.RescoreLimit = DefaultCompressionRescore
+	u.BQ.Enabled = DefaultCompressionEnabled
+	u.BQ.RescoreLimit = DefaultCompressionRescore
+	u.SQ.Enabled = DefaultCompressionEnabled
+	u.SQ.RescoreLimit = DefaultCompressionRescore
+}
+
+// ParseAndValidateConfig from an unknown input value, as this is not further
+// specified in the API to allow of exchanging the index type
+func ParseAndValidateConfig(input interface{}) (schemaConfig.VectorIndexConfig, error) {
+	uc := UserConfig{}
+	uc.SetDefaults()
+
+	if input == nil {
+		return uc, nil
+	}
+
+	asMap, ok := input.(map[string]interface{})
+	if !ok || asMap == nil {
+		return uc, fmt.Errorf("input must be a non-nil map")
+	}
+
+	if err := vectorindexcommon.OptionalStringFromMap(asMap, "distance", func(v string) {
+		uc.Distance = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorindexcommon.OptionalIntFromMap(asMap, "vectorCacheMaxObjects", func(v int) {
+		uc.VectorCacheMaxObjects = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := parseCompression(asMap, &uc); err != nil {
+		return uc, err
+	}
+
+	return uc, nil
+}
+
+func parseCompressionMap(in interface{}, cuc *CompressionUserConfig) error {
+	configMap, ok := in.(map[string]interface{})
+	if ok {
+		if err := vectorindexcommon.OptionalBoolFromMap(configMap, "enabled", func(v bool) {
+			cuc.Enabled = v
+		}); err != nil {
+			return err
+		}
+
+		if err := vectorindexcommon.OptionalBoolFromMap(configMap, "cache", func(v bool) {
+			cuc.Cache = v
+		}); err != nil {
+			return err
+		}
+
+		if err := vectorindexcommon.OptionalIntFromMap(configMap, "rescoreLimit", func(v int) {
+			cuc.RescoreLimit = v
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func parseCompression(in map[string]interface{}, uc *UserConfig) error {
+	pqConfigValue, pqOk := in["pq"]
+	bqConfigValue, bqOk := in["bq"]
+	sqConfigValue, sqOk := in["sq"]
+
+	if !pqOk && !bqOk && !sqOk {
+		return nil
+	}
+
+	if pqOk {
+		err := parseCompressionMap(pqConfigValue, &uc.PQ)
+		if err != nil {
+			return err
+		}
+	}
+
+	if bqOk {
+		err := parseCompressionMap(bqConfigValue, &uc.BQ)
+		if err != nil {
+			return err
+		}
+	}
+
+	if sqOk {
+		err := parseCompressionMap(sqConfigValue, &uc.SQ)
+		if err != nil {
+			return err
+		}
+	}
+
+	compressionConfigs := []CompressionUserConfig{uc.PQ, uc.BQ, uc.SQ}
+	totalEnabled := 0
+
+	for _, compressionConfig := range compressionConfigs {
+		if compressionConfig.Cache && !compressionConfig.Enabled {
+			return errors.New("not possible to use the cache without compression")
+		}
+		if compressionConfig.Enabled {
+			totalEnabled++
+		}
+	}
+
+	if totalEnabled > 1 {
+		return errors.New("cannot enable multiple quantization methods at the same time")
+	}
+
+	// TODO: remove once PQ and SQ are supported
+	if uc.PQ.Enabled {
+		return errors.New("PQ is not currently supported for flat indices")
+	}
+	if uc.SQ.Enabled {
+		return errors.New("SQ is not currently supported for flat indices")
+	}
+
+	return nil
+}
+
+func NewDefaultUserConfig() UserConfig {
+	uc := UserConfig{}
+	uc.SetDefaults()
+	return uc
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/flat/config_test.go

@@ -0,0 +1,148 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package flat
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+func Test_FlatUserConfig(t *testing.T) {
+	type test struct {
+		name         string
+		input        interface{}
+		expected     UserConfig
+		expectErr    bool
+		expectErrMsg string
+	}
+
+	tests := []test{
+		{
+			name:  "nothing specified, all defaults",
+			input: nil,
+			expected: UserConfig{
+				VectorCacheMaxObjects: common.DefaultVectorCacheMaxObjects,
+				Distance:              common.DefaultDistanceMetric,
+				PQ: CompressionUserConfig{
+					Enabled:      DefaultCompressionEnabled,
+					RescoreLimit: DefaultCompressionRescore,
+					Cache:        DefaultVectorCache,
+				},
+				BQ: CompressionUserConfig{
+					Enabled:      DefaultCompressionEnabled,
+					RescoreLimit: DefaultCompressionRescore,
+					Cache:        DefaultVectorCache,
+				},
+				SQ: CompressionUserConfig{
+					Enabled:      DefaultCompressionEnabled,
+					RescoreLimit: DefaultCompressionRescore,
+					Cache:        DefaultVectorCache,
+				},
+			},
+		},
+		{
+			name: "bq enabled",
+			input: map[string]interface{}{
+				"vectorCacheMaxObjects": float64(100),
+				"distance":              "cosine",
+				"bq": map[string]interface{}{
+					"enabled":      true,
+					"rescoreLimit": float64(100),
+					"cache":        true,
+				},
+			},
+			expected: UserConfig{
+				VectorCacheMaxObjects: 100,
+				Distance:              common.DefaultDistanceMetric,
+				PQ: CompressionUserConfig{
+					Enabled:      false,
+					RescoreLimit: DefaultCompressionRescore,
+					Cache:        DefaultVectorCache,
+				},
+				BQ: CompressionUserConfig{
+					Enabled:      true,
+					RescoreLimit: 100,
+					Cache:        true,
+				},
+				SQ: CompressionUserConfig{
+					Enabled:      DefaultCompressionEnabled,
+					RescoreLimit: DefaultCompressionRescore,
+					Cache:        DefaultVectorCache,
+				},
+			},
+		},
+		{
+			name: "sq enabled",
+			input: map[string]interface{}{
+				"vectorCacheMaxObjects": float64(100),
+				"distance":              "cosine",
+				"sq": map[string]interface{}{
+					"enabled":      true,
+					"rescoreLimit": float64(20),
+					"cache":        true,
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "SQ is not currently supported for flat indices",
+		},
+		{
+			name: "pq enabled",
+			input: map[string]interface{}{
+				"vectorCacheMaxObjects": float64(100),
+				"distance":              "cosine",
+				"pq": map[string]interface{}{
+					"enabled":      true,
+					"rescoreLimit": float64(100),
+					"cache":        true,
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "PQ is not currently supported for flat indices",
+		},
+		{
+			name: "sq and bq enabled",
+			input: map[string]interface{}{
+				"vectorCacheMaxObjects": float64(100),
+				"distance":              "cosine",
+				"sq": map[string]interface{}{
+					"enabled":      true,
+					"rescoreLimit": float64(100),
+					"cache":        true,
+				},
+				"bq": map[string]interface{}{
+					"enabled":      true,
+					"rescoreLimit": float64(100),
+					"cache":        true,
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "cannot enable multiple quantization methods at the same time",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cfg, err := ParseAndValidateConfig(test.input)
+			if test.expectErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expectErrMsg)
+				return
+			} else {
+				assert.Nil(t, err)
+				assert.Equal(t, test.expected, cfg)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/bq_config.go

@@ -0,0 +1,42 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import "github.com/weaviate/weaviate/entities/vectorindex/common"
+
+const (
+	DefaultBQEnabled = false
+)
+
+type BQConfig struct {
+	Enabled bool `json:"enabled"`
+}
+
+func parseBQMap(in map[string]interface{}, bq *BQConfig) error {
+	bqConfigValue, ok := in["bq"]
+	if !ok {
+		return nil
+	}
+
+	bqConfigMap, ok := bqConfigValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := common.OptionalBoolFromMap(bqConfigMap, "enabled", func(v bool) {
+		bq.Enabled = v
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/config.go

@@ -0,0 +1,331 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/weaviate/weaviate/entities/schema/config"
+	vectorIndexCommon "github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+const (
+	// Set these defaults if the user leaves them blank
+	DefaultCleanupIntervalSeconds = 5 * 60
+	DefaultMaxConnections         = 32
+	DefaultEFConstruction         = 128
+	DefaultEF                     = -1 // indicates "let Weaviate pick"
+	DefaultDynamicEFMin           = 100
+	DefaultDynamicEFMax           = 500
+	DefaultDynamicEFFactor        = 8
+	DefaultSkip                   = false
+	DefaultFlatSearchCutoff       = 40000
+
+	FilterStrategySweeping = "sweeping"
+	FilterStrategyAcorn    = "acorn"
+
+	DefaultFilterStrategy = FilterStrategySweeping
+
+	// Fail validation if those criteria are not met
+	MinmumMaxConnections  = 4
+	MaximumMaxConnections = 2047
+	MinmumEFConstruction  = 4
+)
+
+// UserConfig bundles all values settable by a user in the per-class settings
+type UserConfig struct {
+	Skip                     bool              `json:"skip"`
+	CleanupIntervalSeconds   int               `json:"cleanupIntervalSeconds"`
+	MaxConnections           int               `json:"maxConnections"`
+	EFConstruction           int               `json:"efConstruction"`
+	EF                       int               `json:"ef"`
+	DynamicEFMin             int               `json:"dynamicEfMin"`
+	DynamicEFMax             int               `json:"dynamicEfMax"`
+	DynamicEFFactor          int               `json:"dynamicEfFactor"`
+	VectorCacheMaxObjects    int               `json:"vectorCacheMaxObjects"`
+	FlatSearchCutoff         int               `json:"flatSearchCutoff"`
+	Distance                 string            `json:"distance"`
+	PQ                       PQConfig          `json:"pq"`
+	BQ                       BQConfig          `json:"bq"`
+	SQ                       SQConfig          `json:"sq"`
+	RQ                       RQConfig          `json:"rq"`
+	FilterStrategy           string            `json:"filterStrategy"`
+	Multivector              MultivectorConfig `json:"multivector"`
+	SkipDefaultQuantization  bool              `json:"skipDefaultQuantization"`
+	TrackDefaultQuantization bool              `json:"trackDefaultQuantization"`
+}
+
+// IndexType returns the type of the underlying vector index, thus making sure
+// the schema.VectorIndexConfig interface is implemented
+func (u UserConfig) IndexType() string {
+	return "hnsw"
+}
+
+func (u UserConfig) DistanceName() string {
+	return u.Distance
+}
+
+func (u UserConfig) IsMultiVector() bool {
+	return u.Multivector.Enabled
+}
+
+// SetDefaults in the user-specifyable part of the config
+func (u *UserConfig) SetDefaults() {
+	u.MaxConnections = DefaultMaxConnections
+	u.EFConstruction = DefaultEFConstruction
+	u.CleanupIntervalSeconds = DefaultCleanupIntervalSeconds
+	u.VectorCacheMaxObjects = vectorIndexCommon.DefaultVectorCacheMaxObjects
+	u.EF = DefaultEF
+	u.DynamicEFFactor = DefaultDynamicEFFactor
+	u.DynamicEFMax = DefaultDynamicEFMax
+	u.DynamicEFMin = DefaultDynamicEFMin
+	u.Skip = DefaultSkip
+	u.FlatSearchCutoff = DefaultFlatSearchCutoff
+	u.Distance = vectorIndexCommon.DefaultDistanceMetric
+	u.PQ = PQConfig{
+		Enabled:        DefaultPQEnabled,
+		BitCompression: DefaultPQBitCompression,
+		Segments:       DefaultPQSegments,
+		Centroids:      DefaultPQCentroids,
+		TrainingLimit:  DefaultPQTrainingLimit,
+		Encoder: PQEncoder{
+			Type:         DefaultPQEncoderType,
+			Distribution: DefaultPQEncoderDistribution,
+		},
+	}
+	u.BQ = BQConfig{
+		Enabled: DefaultBQEnabled,
+	}
+	u.SQ = SQConfig{
+		Enabled:       DefaultSQEnabled,
+		TrainingLimit: DefaultSQTrainingLimit,
+		RescoreLimit:  DefaultSQRescoreLimit,
+	}
+	u.RQ = RQConfig{
+		Enabled:      DefaultRQEnabled,
+		Bits:         DefaultRQBits,
+		RescoreLimit: DefaultRQRescoreLimit,
+	}
+	if strategy := os.Getenv("HNSW_DEFAULT_FILTER_STRATEGY"); strategy == FilterStrategyAcorn {
+		u.FilterStrategy = FilterStrategyAcorn
+	} else {
+		u.FilterStrategy = FilterStrategySweeping
+	}
+	u.Multivector = MultivectorConfig{
+		Aggregation: DefaultMultivectorAggregation,
+		Enabled:     DefaultMultivectorEnabled,
+		MuveraConfig: MuveraConfig{
+			Enabled:      DefaultMultivectorMuveraEnabled,
+			KSim:         DefaultMultivectorKSim,
+			DProjections: DefaultMultivectorDProjections,
+			Repetitions:  DefaultMultivectorRepetitions,
+		},
+	}
+}
+
+// ParseAndValidateConfig from an unknown input value, as this is not further
+// specified in the API to allow of exchanging the index type
+func ParseAndValidateConfig(input interface{}, isMultiVector bool) (config.VectorIndexConfig, error) {
+	uc := UserConfig{}
+	uc.SetDefaults()
+
+	if input == nil {
+		return uc, nil
+	}
+
+	asMap, ok := input.(map[string]interface{})
+	if !ok || asMap == nil {
+		return uc, fmt.Errorf("input must be a non-nil map")
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "maxConnections", func(v int) {
+		uc.MaxConnections = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "cleanupIntervalSeconds", func(v int) {
+		uc.CleanupIntervalSeconds = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "efConstruction", func(v int) {
+		uc.EFConstruction = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "ef", func(v int) {
+		uc.EF = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "dynamicEfFactor", func(v int) {
+		uc.DynamicEFFactor = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "dynamicEfMax", func(v int) {
+		uc.DynamicEFMax = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "dynamicEfMin", func(v int) {
+		uc.DynamicEFMin = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "vectorCacheMaxObjects", func(v int) {
+		uc.VectorCacheMaxObjects = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalIntFromMap(asMap, "flatSearchCutoff", func(v int) {
+		uc.FlatSearchCutoff = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalBoolFromMap(asMap, "skip", func(v bool) {
+		uc.Skip = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalStringFromMap(asMap, "distance", func(v string) {
+		uc.Distance = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := parsePQMap(asMap, &uc.PQ); err != nil {
+		return uc, err
+	}
+
+	if err := parseBQMap(asMap, &uc.BQ); err != nil {
+		return uc, err
+	}
+
+	if err := parseSQMap(asMap, &uc.SQ); err != nil {
+		return uc, err
+	}
+
+	if err := parseRQMap(asMap, &uc.RQ); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalStringFromMap(asMap, "filterStrategy", func(v string) {
+		uc.FilterStrategy = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := parseMultivectorMap(asMap, &uc.Multivector, isMultiVector); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalBoolFromMap(asMap, "skipDefaultQuantization", func(v bool) {
+		uc.SkipDefaultQuantization = v
+	}); err != nil {
+		return uc, err
+	}
+
+	if err := vectorIndexCommon.OptionalBoolFromMap(asMap, "trackDefaultQuantization", func(v bool) {
+		uc.TrackDefaultQuantization = v
+	}); err != nil {
+		return uc, err
+	}
+
+	return uc, uc.validate()
+}
+
+func (u *UserConfig) validate() error {
+	var errMsgs []string
+	if u.MaxConnections < MinmumMaxConnections {
+		errMsgs = append(errMsgs, fmt.Sprintf(
+			"maxConnections must be a positive integer with a minimum of %d",
+			MinmumMaxConnections,
+		))
+	}
+
+	if u.MaxConnections > MaximumMaxConnections {
+		errMsgs = append(errMsgs, fmt.Sprintf(
+			"maxConnections must be less than %d",
+			MaximumMaxConnections+1,
+		))
+	}
+
+	if u.EFConstruction < MinmumEFConstruction {
+		errMsgs = append(errMsgs, fmt.Sprintf(
+			"efConstruction must be a positive integer with a minimum of %d",
+			MinmumMaxConnections,
+		))
+	}
+
+	if u.FilterStrategy != FilterStrategySweeping && u.FilterStrategy != FilterStrategyAcorn {
+		errMsgs = append(errMsgs, "filterStrategy must be either 'sweeping' or 'acorn'")
+	}
+
+	if len(errMsgs) > 0 {
+		return fmt.Errorf("invalid hnsw config: %s",
+			strings.Join(errMsgs, ", "))
+	}
+
+	enabled := 0
+	if u.PQ.Enabled {
+		enabled++
+	}
+	if u.BQ.Enabled {
+		enabled++
+	}
+	if u.SQ.Enabled {
+		enabled++
+	}
+	if u.RQ.Enabled {
+		enabled++
+	}
+	if enabled > 1 {
+		return fmt.Errorf("invalid hnsw config: more than a single compression methods enabled")
+	}
+
+	err := ValidateRQConfig(u.RQ)
+	if err != nil {
+		return err
+	}
+
+	if u.Multivector.MuveraConfig.Enabled && u.Multivector.MuveraConfig.KSim > 10 {
+		return fmt.Errorf("invalid hnsw config: ksim must be less than 10")
+	}
+
+	return nil
+}
+
+func NewDefaultUserConfig() UserConfig {
+	uc := UserConfig{}
+	uc.SetDefaults()
+	return uc
+}
+
+func NewDefaultMultiVectorUserConfig() UserConfig {
+	uc := UserConfig{}
+	uc.SetDefaults()
+	uc.Multivector = MultivectorConfig{Enabled: true}
+	return uc
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/config_test.go

@@ -0,0 +1,1148 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import (
+	"encoding/json"
+	"math"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+func Test_UserConfig(t *testing.T) {
+	type test struct {
+		name         string
+		input        interface{}
+		expected     UserConfig
+		expectErr    bool
+		expectErrMsg string
+	}
+
+	tests := []test{
+		{
+			name:  "nothing specified, all defaults",
+			input: nil,
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         DefaultMaxConnections,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with maximum connections",
+			input: map[string]interface{}{
+				"maxConnections": json.Number("100"),
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         100,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with all optional fields",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": json.Number("11"),
+				"maxConnections":         json.Number("12"),
+				"efConstruction":         json.Number("13"),
+				"vectorCacheMaxObjects":  json.Number("14"),
+				"ef":                     json.Number("15"),
+				"flatSearchCutoff":       json.Number("16"),
+				"dynamicEfMin":           json.Number("17"),
+				"dynamicEfMax":           json.Number("18"),
+				"dynamicEfFactor":        json.Number("19"),
+				"skip":                   true,
+				"distance":               "l2-squared",
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Skip:                   true,
+				Distance:               "l2-squared",
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with all optional fields",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": json.Number("11"),
+				"maxConnections":         json.Number("12"),
+				"efConstruction":         json.Number("13"),
+				"vectorCacheMaxObjects":  json.Number("14"),
+				"ef":                     json.Number("15"),
+				"flatSearchCutoff":       json.Number("16"),
+				"dynamicEfMin":           json.Number("17"),
+				"dynamicEfMax":           json.Number("18"),
+				"dynamicEfFactor":        json.Number("19"),
+				"skip":                   true,
+				"distance":               "manhattan",
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Skip:                   true,
+				Distance:               "manhattan",
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with all optional fields",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": json.Number("11"),
+				"maxConnections":         json.Number("12"),
+				"efConstruction":         json.Number("13"),
+				"vectorCacheMaxObjects":  json.Number("14"),
+				"ef":                     json.Number("15"),
+				"flatSearchCutoff":       json.Number("16"),
+				"dynamicEfMin":           json.Number("17"),
+				"dynamicEfMax":           json.Number("18"),
+				"dynamicEfFactor":        json.Number("19"),
+				"skip":                   true,
+				"distance":               "hamming",
+				"filterStrategy":         "sweeping",
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Skip:                   true,
+				Distance:               "hamming",
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			// opposed to from the API
+			name: "with raw data as floats",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": float64(11),
+				"maxConnections":         float64(12),
+				"efConstruction":         float64(13),
+				"vectorCacheMaxObjects":  float64(14),
+				"ef":                     float64(15),
+				"flatSearchCutoff":       float64(16),
+				"dynamicEfMin":           float64(17),
+				"dynamicEfMax":           float64(18),
+				"dynamicEfFactor":        float64(19),
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with pq tile normal encoder",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": float64(11),
+				"maxConnections":         float64(12),
+				"efConstruction":         float64(13),
+				"vectorCacheMaxObjects":  float64(14),
+				"ef":                     float64(15),
+				"flatSearchCutoff":       float64(16),
+				"dynamicEfMin":           float64(17),
+				"dynamicEfMax":           float64(18),
+				"dynamicEfFactor":        float64(19),
+				"pq": map[string]interface{}{
+					"enabled":        true,
+					"bitCompression": false,
+					"segments":       float64(64),
+					"centroids":      float64(DefaultPQCentroids),
+					"trainingLimit":  float64(DefaultPQTrainingLimit),
+					"encoder": map[string]interface{}{
+						"type":         "tile",
+						"distribution": "normal",
+					},
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:       true,
+					Segments:      64,
+					Centroids:     DefaultPQCentroids,
+					TrainingLimit: DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         "tile",
+						Distribution: "normal",
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with pq kmeans normal encoder",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": float64(11),
+				"maxConnections":         float64(12),
+				"efConstruction":         float64(13),
+				"vectorCacheMaxObjects":  float64(14),
+				"ef":                     float64(15),
+				"flatSearchCutoff":       float64(16),
+				"dynamicEfMin":           float64(17),
+				"dynamicEfMax":           float64(18),
+				"dynamicEfFactor":        float64(19),
+				"pq": map[string]interface{}{
+					"enabled":        true,
+					"bitCompression": false,
+					"segments":       float64(64),
+					"centroids":      float64(DefaultPQCentroids),
+					"trainingLimit":  float64(DefaultPQTrainingLimit),
+					"encoder": map[string]interface{}{
+						"type": PQEncoderTypeKMeans,
+					},
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:       true,
+					Segments:      64,
+					Centroids:     DefaultPQCentroids,
+					TrainingLimit: DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+
+		{
+			name: "with invalid encoder",
+			input: map[string]interface{}{
+				"pq": map[string]interface{}{
+					"enabled": true,
+					"encoder": map[string]interface{}{
+						"type": "bernoulli",
+					},
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "invalid encoder type bernoulli",
+		},
+
+		{
+			name: "with invalid distribution",
+			input: map[string]interface{}{
+				"pq": map[string]interface{}{
+					"enabled": true,
+					"encoder": map[string]interface{}{
+						"distribution": "lognormal",
+					},
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "invalid encoder distribution lognormal",
+		},
+
+		{
+			// opposed to from the API
+			name: "with rounded vectorCacheMaxObjects that would otherwise overflow",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": json.Number("11"),
+				"maxConnections":         json.Number("12"),
+				"efConstruction":         json.Number("13"),
+				"vectorCacheMaxObjects":  json.Number("9223372036854776000"),
+				"ef":                     json.Number("15"),
+				"flatSearchCutoff":       json.Number("16"),
+				"dynamicEfMin":           json.Number("17"),
+				"dynamicEfMax":           json.Number("18"),
+				"dynamicEfFactor":        json.Number("19"),
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  math.MaxInt64,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "invalid max connections (json)",
+			input: map[string]interface{}{
+				"maxConnections": json.Number("0"),
+			},
+			expectErr: true,
+			expectErrMsg: "maxConnections must be a positive integer " +
+				"with a minimum of 4",
+		},
+		{
+			name: "invalid max connections (float)",
+			input: map[string]interface{}{
+				"maxConnections": float64(3),
+			},
+			expectErr: true,
+			expectErrMsg: "maxConnections must be a positive integer " +
+				"with a minimum of 4",
+		},
+		{
+			name: "invalid efConstruction (json)",
+			input: map[string]interface{}{
+				"efConstruction": json.Number("0"),
+			},
+			expectErr: true,
+			expectErrMsg: "efConstruction must be a positive integer " +
+				"with a minimum of 4",
+		},
+		{
+			name: "invalid efConstruction (float)",
+			input: map[string]interface{}{
+				"efConstruction": float64(3),
+			},
+			expectErr: true,
+			expectErrMsg: "efConstruction must be a positive integer " +
+				"with a minimum of 4",
+		},
+		{
+			name: "with bq",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": float64(11),
+				"maxConnections":         float64(12),
+				"efConstruction":         float64(13),
+				"vectorCacheMaxObjects":  float64(14),
+				"ef":                     float64(15),
+				"flatSearchCutoff":       float64(16),
+				"dynamicEfMin":           float64(17),
+				"dynamicEfMax":           float64(18),
+				"dynamicEfFactor":        float64(19),
+				"bq": map[string]interface{}{
+					"enabled": true,
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:       false,
+					Segments:      0,
+					Centroids:     DefaultPQCentroids,
+					TrainingLimit: DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				BQ: BQConfig{
+					Enabled: true,
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "with sq",
+			input: map[string]interface{}{
+				"cleanupIntervalSeconds": float64(11),
+				"maxConnections":         float64(12),
+				"efConstruction":         float64(13),
+				"vectorCacheMaxObjects":  float64(14),
+				"ef":                     float64(15),
+				"flatSearchCutoff":       float64(16),
+				"dynamicEfMin":           float64(17),
+				"dynamicEfMax":           float64(18),
+				"dynamicEfFactor":        float64(19),
+				"sq": map[string]interface{}{
+					"enabled": true,
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: 11,
+				MaxConnections:         12,
+				EFConstruction:         13,
+				VectorCacheMaxObjects:  14,
+				EF:                     15,
+				FlatSearchCutoff:       16,
+				DynamicEFMin:           17,
+				DynamicEFMax:           18,
+				DynamicEFFactor:        19,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:       false,
+					Segments:      0,
+					Centroids:     DefaultPQCentroids,
+					TrainingLimit: DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       true,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "with invalid compression",
+			input: map[string]interface{}{
+				"pq": map[string]interface{}{
+					"enabled": true,
+					"encoder": map[string]interface{}{
+						"type": "kmeans",
+					},
+				},
+				"bq": map[string]interface{}{
+					"enabled": true,
+				},
+			},
+			expectErr:    true,
+			expectErrMsg: "invalid hnsw config: more than a single compression methods enabled",
+		},
+		{
+			name: "with invalid filter strategy",
+			input: map[string]interface{}{
+				"filterStrategy": "chestnut",
+			},
+			expectErr:    true,
+			expectErrMsg: "invalid hnsw config: filterStrategy must be either 'sweeping' or 'acorn'",
+		},
+		{
+			name: "acorn enabled, all defaults",
+			input: map[string]interface{}{
+				"filterStrategy": "acorn",
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         DefaultMaxConnections,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: FilterStrategyAcorn,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "max connections at maximum allowed value (2047)",
+			input: map[string]interface{}{
+				"maxConnections": json.Number("2047"),
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         2047,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      DefaultRQEnabled,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "max connections exceeds maximum allowed value (2048)",
+			input: map[string]interface{}{
+				"maxConnections": json.Number("2048"),
+			},
+			expectErr:    true,
+			expectErrMsg: "maxConnections must be less than 2048",
+		},
+		{
+			name: "with rq defaults",
+			input: map[string]interface{}{
+				"rq": map[string]interface{}{
+					"enabled": true,
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         DefaultMaxConnections,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      true,
+					Bits:         DefaultRQBits,
+					RescoreLimit: DefaultRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "with rq 8 and rescore limit 0",
+			input: map[string]interface{}{
+				"rq": map[string]interface{}{
+					"enabled":      true,
+					"bits":         float64(8),
+					"rescoreLimit": float64(0),
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         DefaultMaxConnections,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      true,
+					Bits:         DefaultRQBits,
+					RescoreLimit: 0,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "with rq 1",
+			input: map[string]interface{}{
+				"rq": map[string]interface{}{
+					"enabled": true,
+					"bits":    float64(1),
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         DefaultMaxConnections,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      true,
+					Bits:         1,
+					RescoreLimit: DefaultBRQRescoreLimit,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+		{
+			name: "with rq 1 and rescore limit 100",
+			input: map[string]interface{}{
+				"rq": map[string]interface{}{
+					"enabled":      true,
+					"bits":         float64(1),
+					"rescoreLimit": float64(100),
+				},
+			},
+			expected: UserConfig{
+				CleanupIntervalSeconds: DefaultCleanupIntervalSeconds,
+				MaxConnections:         DefaultMaxConnections,
+				EFConstruction:         DefaultEFConstruction,
+				VectorCacheMaxObjects:  common.DefaultVectorCacheMaxObjects,
+				EF:                     DefaultEF,
+				Skip:                   DefaultSkip,
+				FlatSearchCutoff:       DefaultFlatSearchCutoff,
+				DynamicEFMin:           DefaultDynamicEFMin,
+				DynamicEFMax:           DefaultDynamicEFMax,
+				DynamicEFFactor:        DefaultDynamicEFFactor,
+				Distance:               common.DefaultDistanceMetric,
+				PQ: PQConfig{
+					Enabled:        DefaultPQEnabled,
+					BitCompression: DefaultPQBitCompression,
+					Segments:       DefaultPQSegments,
+					Centroids:      DefaultPQCentroids,
+					TrainingLimit:  DefaultPQTrainingLimit,
+					Encoder: PQEncoder{
+						Type:         DefaultPQEncoderType,
+						Distribution: DefaultPQEncoderDistribution,
+					},
+				},
+				SQ: SQConfig{
+					Enabled:       DefaultSQEnabled,
+					TrainingLimit: DefaultSQTrainingLimit,
+					RescoreLimit:  DefaultSQRescoreLimit,
+				},
+				RQ: RQConfig{
+					Enabled:      true,
+					Bits:         1,
+					RescoreLimit: 100,
+				},
+				FilterStrategy: DefaultFilterStrategy,
+				Multivector: MultivectorConfig{
+					Enabled:     DefaultMultivectorEnabled,
+					Aggregation: DefaultMultivectorAggregation,
+					MuveraConfig: MuveraConfig{
+						Enabled:      DefaultMultivectorMuveraEnabled,
+						KSim:         DefaultMultivectorKSim,
+						DProjections: DefaultMultivectorDProjections,
+						Repetitions:  DefaultMultivectorRepetitions,
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cfg, err := ParseAndValidateConfig(test.input, false)
+			if test.expectErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expectErrMsg)
+				return
+			} else {
+				assert.Nil(t, err)
+				assert.Equal(t, test.expected, cfg)
+			}
+		})
+	}
+}
+
+func Test_UserConfigFilterStrategy(t *testing.T) {
+	t.Run("default filter strategy is sweeping", func(t *testing.T) {
+		cfg := UserConfig{}
+		cfg.SetDefaults()
+		assert.Equal(t, FilterStrategySweeping, cfg.FilterStrategy)
+	})
+
+	t.Run("can override default strategy", func(t *testing.T) {
+		os.Setenv("HNSW_DEFAULT_FILTER_STRATEGY", FilterStrategyAcorn)
+		cfg := UserConfig{}
+		cfg.SetDefaults()
+		assert.Equal(t, FilterStrategyAcorn, cfg.FilterStrategy)
+		assert.Nil(t, os.Unsetenv("HNSW_DEFAULT_FILTER_STRATEGY"))
+	})
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/multivector_config.go

@@ -0,0 +1,132 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import (
+	"fmt"
+
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+const (
+	MultivectorAggregationMaxSim = "maxSim"
+)
+
+const (
+	DefaultMultivectorEnabled       = false
+	DefaultMultivectorMuveraEnabled = false
+	DefaultMultivectorKSim          = 4
+	DefaultMultivectorDProjections  = 16
+	DefaultMultivectorRepetitions   = 10
+	DefaultMultivectorAggregation   = "maxSim"
+)
+
+// Multivector configuration
+type MultivectorConfig struct {
+	Enabled      bool         `json:"enabled"`
+	MuveraConfig MuveraConfig `json:"muvera"`
+	Aggregation  string       `json:"aggregation"`
+}
+
+type MuveraConfig struct {
+	Enabled      bool `json:"enabled"`
+	KSim         int  `json:"ksim"`
+	DProjections int  `json:"dprojections"`
+	Repetitions  int  `json:"repetitions"`
+}
+
+func validAggregation(v string) error {
+	switch v {
+	case MultivectorAggregationMaxSim:
+	default:
+		return fmt.Errorf("invalid aggregation type %s", v)
+	}
+
+	return nil
+}
+
+func ValidateMultivectorConfig(cfg MultivectorConfig) error {
+	if !cfg.Enabled {
+		return nil
+	}
+	err := validAggregation(cfg.Aggregation)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func parseMultivectorMap(in map[string]interface{}, multivector *MultivectorConfig, isMultiVector bool) error {
+	multivectorConfigValue, ok := in["multivector"]
+	if !ok {
+		return nil
+	}
+
+	multivectorConfigMap, ok := multivectorConfigValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := common.OptionalBoolFromMap(multivectorConfigMap, "enabled", func(v bool) {
+		if isMultiVector {
+			// vectorizer set is a multi vector vectorizer, enable multi vector index
+			multivector.Enabled = true
+		} else {
+			multivector.Enabled = v
+		}
+	}); err != nil {
+		return err
+	}
+
+	muveraValue, ok := multivectorConfigMap["muvera"]
+	if !ok {
+		return nil
+	}
+
+	muveraMap, ok := muveraValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := common.OptionalBoolFromMap(muveraMap, "enabled", func(v bool) {
+		multivector.MuveraConfig.Enabled = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(muveraMap, "ksim", func(v int) {
+		multivector.MuveraConfig.KSim = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(muveraMap, "dprojections", func(v int) {
+		multivector.MuveraConfig.DProjections = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(muveraMap, "repetitions", func(v int) {
+		multivector.MuveraConfig.Repetitions = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalStringFromMap(multivectorConfigMap, "aggregation", func(v string) {
+		multivector.Aggregation = v
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/pq_config.go

@@ -0,0 +1,196 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import (
+	"fmt"
+
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+const (
+	PQEncoderTypeKMeans            = "kmeans"
+	PQEncoderTypeTile              = "tile"
+	PQEncoderDistributionLogNormal = "log-normal"
+	PQEncoderDistributionNormal    = "normal"
+)
+
+const (
+	DefaultPQEnabled             = false
+	DefaultPQBitCompression      = false
+	DefaultPQSegments            = 0
+	DefaultPQEncoderType         = PQEncoderTypeKMeans
+	DefaultPQEncoderDistribution = PQEncoderDistributionLogNormal
+	DefaultPQCentroids           = 256
+	DefaultPQTrainingLimit       = 100000
+)
+
+// Product Quantization encoder configuration
+type PQEncoder struct {
+	Type         string `json:"type"`
+	Distribution string `json:"distribution,omitempty"`
+}
+
+// Product Quantization configuration
+type PQConfig struct {
+	Enabled        bool      `json:"enabled"`
+	BitCompression bool      `json:"bitCompression"`
+	Segments       int       `json:"segments"`
+	Centroids      int       `json:"centroids"`
+	TrainingLimit  int       `json:"trainingLimit"`
+	Encoder        PQEncoder `json:"encoder"`
+}
+
+func validEncoder(v string) error {
+	switch v {
+	case PQEncoderTypeKMeans:
+	case PQEncoderTypeTile:
+	default:
+		return fmt.Errorf("invalid encoder type %s", v)
+	}
+
+	return nil
+}
+
+func validEncoderDistribution(v string) error {
+	switch v {
+	case PQEncoderDistributionLogNormal:
+	case PQEncoderDistributionNormal:
+	default:
+		return fmt.Errorf("invalid encoder distribution %s", v)
+	}
+
+	return nil
+}
+
+func ValidatePQConfig(cfg PQConfig) error {
+	if !cfg.Enabled {
+		return nil
+	}
+	err := validEncoder(cfg.Encoder.Type)
+	if err != nil {
+		return err
+	}
+
+	err = validEncoderDistribution(cfg.Encoder.Distribution)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func encoderFromMap(in map[string]interface{}, setFn func(v string)) error {
+	value, ok := in["type"]
+	if !ok {
+		return nil
+	}
+
+	asString, ok := value.(string)
+	if !ok {
+		return nil
+	}
+
+	err := validEncoder(asString)
+	if err != nil {
+		return err
+	}
+
+	setFn(asString)
+	return nil
+}
+
+func encoderDistributionFromMap(in map[string]interface{}, setFn func(v string)) error {
+	value, ok := in["distribution"]
+	if !ok {
+		return nil
+	}
+
+	asString, ok := value.(string)
+	if !ok {
+		return nil
+	}
+
+	err := validEncoderDistribution(asString)
+	if err != nil {
+		return err
+	}
+
+	setFn(asString)
+	return nil
+}
+
+func parsePQMap(in map[string]interface{}, pq *PQConfig) error {
+	pqConfigValue, ok := in["pq"]
+	if !ok {
+		return nil
+	}
+
+	pqConfigMap, ok := pqConfigValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := common.OptionalBoolFromMap(pqConfigMap, "enabled", func(v bool) {
+		pq.Enabled = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalBoolFromMap(pqConfigMap, "bitCompression", func(v bool) {
+		pq.BitCompression = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(pqConfigMap, "segments", func(v int) {
+		pq.Segments = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(pqConfigMap, "centroids", func(v int) {
+		pq.Centroids = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(pqConfigMap, "trainingLimit", func(v int) {
+		pq.TrainingLimit = v
+	}); err != nil {
+		return err
+	}
+
+	pqEncoderValue, ok := pqConfigMap["encoder"]
+	if !ok {
+		return nil
+	}
+
+	pqEncoderMap, ok := pqEncoderValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := encoderFromMap(pqEncoderMap, func(v string) {
+		pq.Encoder.Type = v
+	}); err != nil {
+		return err
+	}
+
+	if err := encoderDistributionFromMap(pqEncoderMap, func(v string) {
+		pq.Encoder.Distribution = v
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/rq_config.go

@@ -0,0 +1,87 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import (
+	"errors"
+
+	"github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+)
+
+const (
+	DefaultRQEnabled       = false
+	DefaultRQBits          = 8
+	DefaultRQRescoreLimit  = 20
+	DefaultBRQRescoreLimit = 512
+)
+
+type RQConfig struct {
+	Enabled      bool  `json:"enabled"`
+	Bits         int16 `json:"bits"`
+	RescoreLimit int   `json:"rescoreLimit"`
+}
+
+func ValidateRQConfig(cfg RQConfig) error {
+	if !cfg.Enabled {
+		return nil
+	}
+	if cfg.Bits != 8 && cfg.Bits != 1 {
+		return errors.New("RQ bits must be 8 or 1")
+	}
+
+	return nil
+}
+
+func parseRQMap(in map[string]interface{}, rq *RQConfig) error {
+	rqConfigValue, ok := in["rq"]
+	if !ok {
+		return nil
+	}
+
+	rqConfigMap, ok := rqConfigValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := common.OptionalBoolFromMap(rqConfigMap, "enabled", func(v bool) {
+		rq.Enabled = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(rqConfigMap, "bits", func(v int) {
+		rq.Bits = int16(v)
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(rqConfigMap, "rescoreLimit", func(v int) {
+		rq.RescoreLimit = v
+	}); err != nil {
+		return err
+	}
+
+	if rq.Bits == 1 && rqConfigMap["rescoreLimit"] == nil {
+		rq.RescoreLimit = DefaultBRQRescoreLimit
+	}
+
+	return nil
+}
+
+// GetRQBits returns the bits value for RQ compression, or 0 if not RQ
+func GetRQBits(cfg config.VectorIndexConfig) int16 {
+	if hnswUserConfig, ok := cfg.(UserConfig); ok && hnswUserConfig.RQ.Enabled {
+		return hnswUserConfig.RQ.Bits
+	}
+	return 0
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/rq_config_test.go

@@ -0,0 +1,75 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/schema/config"
+)
+
+func TestGetRQBits(t *testing.T) {
+	tests := []struct {
+		name     string
+		config   config.VectorIndexConfig
+		expected int16
+	}{
+		{
+			name: "RQ disabled should return 0",
+			config: UserConfig{
+				RQ: RQConfig{
+					Enabled: false,
+					Bits:    8,
+				},
+			},
+			expected: 0,
+		},
+		{
+			name: "RQ enabled with bits=1 should return 1",
+			config: UserConfig{
+				RQ: RQConfig{
+					Enabled: true,
+					Bits:    1,
+				},
+			},
+			expected: 1,
+		},
+		{
+			name: "RQ enabled with bits=8 should return 8",
+			config: UserConfig{
+				RQ: RQConfig{
+					Enabled: true,
+					Bits:    8,
+				},
+			},
+			expected: 8,
+		},
+		{
+			name: "non-RQ config should return 0",
+			config: UserConfig{
+				BQ: BQConfig{
+					Enabled: true,
+				},
+			},
+			expected: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := GetRQBits(tt.config)
+			if result != tt.expected {
+				t.Errorf("GetRQBits() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/entities/vectorindex/hnsw/sq_config.go

@@ -0,0 +1,58 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package hnsw
+
+import "github.com/weaviate/weaviate/entities/vectorindex/common"
+
+const (
+	DefaultSQEnabled       = false
+	DefaultSQTrainingLimit = 100000
+	DefaultSQRescoreLimit  = 20
+)
+
+type SQConfig struct {
+	Enabled       bool `json:"enabled"`
+	TrainingLimit int  `json:"trainingLimit"`
+	RescoreLimit  int  `json:"rescoreLimit"`
+}
+
+func parseSQMap(in map[string]interface{}, sq *SQConfig) error {
+	sqConfigValue, ok := in["sq"]
+	if !ok {
+		return nil
+	}
+
+	sqConfigMap, ok := sqConfigValue.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	if err := common.OptionalBoolFromMap(sqConfigMap, "enabled", func(v bool) {
+		sq.Enabled = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(sqConfigMap, "trainingLimit", func(v int) {
+		sq.TrainingLimit = v
+	}); err != nil {
+		return err
+	}
+
+	if err := common.OptionalIntFromMap(sqConfigMap, "rescoreLimit", func(v int) {
+		sq.RescoreLimit = v
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/entities/verbosity/verbosity.go

@@ -0,0 +1,34 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package verbosity
+
+import "fmt"
+
+const (
+	OutputMinimal = "minimal"
+	OutputVerbose = "verbose"
+)
+
+// ParseOutput extracts the verbosity value from the provided nullable string
+// If `output` is nil, the default selection is "minimal"
+func ParseOutput(output *string) (string, error) {
+	if output != nil {
+		switch *output {
+		case OutputMinimal, OutputVerbose:
+			return *output, nil
+		default:
+			return "", fmt.Errorf(`invalid output: "%s", possible values are: "%s", "%s"`,
+				*output, OutputMinimal, OutputVerbose)
+		}
+	}
+	return OutputMinimal, nil
+}

platform/dbops/binaries/weaviate-src/entities/versioned/class.go

@@ -0,0 +1,23 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package versioned
+
+import "github.com/weaviate/weaviate/entities/models"
+
+// Class is a wrapper on top of class created by OpenAPI to be able
+// to inject version to class
+type Class struct {
+	*models.Class
+	Version uint64
+}
+
+type Classes map[string]Class

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v0/batch.pb.go

@@ -0,0 +1,149 @@
+// 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"
+)
+
+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 BatchObjectsRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchObjectsRequest) Reset() {
+	*x = BatchObjectsRequest{}
+	mi := &file_v0_batch_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObjectsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObjectsRequest) ProtoMessage() {}
+
+func (x *BatchObjectsRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v0_batch_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 BatchObjectsRequest.ProtoReflect.Descriptor instead.
+func (*BatchObjectsRequest) Descriptor() ([]byte, []int) {
+	return file_v0_batch_proto_rawDescGZIP(), []int{0}
+}
+
+type BatchObjectsReply struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchObjectsReply) Reset() {
+	*x = BatchObjectsReply{}
+	mi := &file_v0_batch_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObjectsReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObjectsReply) ProtoMessage() {}
+
+func (x *BatchObjectsReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v0_batch_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 BatchObjectsReply.ProtoReflect.Descriptor instead.
+func (*BatchObjectsReply) Descriptor() ([]byte, []int) {
+	return file_v0_batch_proto_rawDescGZIP(), []int{1}
+}
+
+var File_v0_batch_proto protoreflect.FileDescriptor
+
+const file_v0_batch_proto_rawDesc = "" +
+	"\n" +
+	"\x0ev0/batch.proto\x12\fweaviategrpc\"\x15\n" +
+	"\x13BatchObjectsRequest\"\x13\n" +
+	"\x11BatchObjectsReplyBo\n" +
+	"#io.weaviate.client.grpc.protocol.v0B\x12WeaviateProtoBatchZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v0_batch_proto_rawDescOnce sync.Once
+	file_v0_batch_proto_rawDescData []byte
+)
+
+func file_v0_batch_proto_rawDescGZIP() []byte {
+	file_v0_batch_proto_rawDescOnce.Do(func() {
+		file_v0_batch_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v0_batch_proto_rawDesc), len(file_v0_batch_proto_rawDesc)))
+	})
+	return file_v0_batch_proto_rawDescData
+}
+
+var file_v0_batch_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_v0_batch_proto_goTypes = []any{
+	(*BatchObjectsRequest)(nil), // 0: weaviategrpc.BatchObjectsRequest
+	(*BatchObjectsReply)(nil),   // 1: weaviategrpc.BatchObjectsReply
+}
+var file_v0_batch_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_v0_batch_proto_init() }
+func file_v0_batch_proto_init() {
+	if File_v0_batch_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v0_batch_proto_rawDesc), len(file_v0_batch_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v0_batch_proto_goTypes,
+		DependencyIndexes: file_v0_batch_proto_depIdxs,
+		MessageInfos:      file_v0_batch_proto_msgTypes,
+	}.Build()
+	File_v0_batch_proto = out.File
+	file_v0_batch_proto_goTypes = nil
+	file_v0_batch_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v0/search_get.pb.go

@@ -0,0 +1,149 @@
+// 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"
+)
+
+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 SearchRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *SearchRequest) Reset() {
+	*x = SearchRequest{}
+	mi := &file_v0_search_get_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *SearchRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SearchRequest) ProtoMessage() {}
+
+func (x *SearchRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v0_search_get_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 SearchRequest.ProtoReflect.Descriptor instead.
+func (*SearchRequest) Descriptor() ([]byte, []int) {
+	return file_v0_search_get_proto_rawDescGZIP(), []int{0}
+}
+
+type SearchReply struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *SearchReply) Reset() {
+	*x = SearchReply{}
+	mi := &file_v0_search_get_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *SearchReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SearchReply) ProtoMessage() {}
+
+func (x *SearchReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v0_search_get_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 SearchReply.ProtoReflect.Descriptor instead.
+func (*SearchReply) Descriptor() ([]byte, []int) {
+	return file_v0_search_get_proto_rawDescGZIP(), []int{1}
+}
+
+var File_v0_search_get_proto protoreflect.FileDescriptor
+
+const file_v0_search_get_proto_rawDesc = "" +
+	"\n" +
+	"\x13v0/search_get.proto\x12\fweaviategrpc\"\x0f\n" +
+	"\rSearchRequest\"\r\n" +
+	"\vSearchReplyBs\n" +
+	"#io.weaviate.client.grpc.protocol.v0B\x16WeaviateProtoSearchGetZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v0_search_get_proto_rawDescOnce sync.Once
+	file_v0_search_get_proto_rawDescData []byte
+)
+
+func file_v0_search_get_proto_rawDescGZIP() []byte {
+	file_v0_search_get_proto_rawDescOnce.Do(func() {
+		file_v0_search_get_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v0_search_get_proto_rawDesc), len(file_v0_search_get_proto_rawDesc)))
+	})
+	return file_v0_search_get_proto_rawDescData
+}
+
+var file_v0_search_get_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_v0_search_get_proto_goTypes = []any{
+	(*SearchRequest)(nil), // 0: weaviategrpc.SearchRequest
+	(*SearchReply)(nil),   // 1: weaviategrpc.SearchReply
+}
+var file_v0_search_get_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_v0_search_get_proto_init() }
+func file_v0_search_get_proto_init() {
+	if File_v0_search_get_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v0_search_get_proto_rawDesc), len(file_v0_search_get_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v0_search_get_proto_goTypes,
+		DependencyIndexes: file_v0_search_get_proto_depIdxs,
+		MessageInfos:      file_v0_search_get_proto_msgTypes,
+	}.Build()
+	File_v0_search_get_proto = out.File
+	file_v0_search_get_proto_goTypes = nil
+	file_v0_search_get_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v0/weaviate.pb.go

@@ -0,0 +1,71 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+
+package protocol
+
+import (
+	reflect "reflect"
+	unsafe "unsafe"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+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)
+)
+
+var File_v0_weaviate_proto protoreflect.FileDescriptor
+
+const file_v0_weaviate_proto_rawDesc = "" +
+	"\n" +
+	"\x11v0/weaviate.proto\x12\fweaviategrpc\x1a\x0ev0/batch.proto\x1a\x13v0/search_get.proto2\xa4\x01\n" +
+	"\bWeaviate\x12B\n" +
+	"\x06Search\x12\x1b.weaviategrpc.SearchRequest\x1a\x19.weaviategrpc.SearchReply\"\x00\x12T\n" +
+	"\fBatchObjects\x12!.weaviategrpc.BatchObjectsRequest\x1a\x1f.weaviategrpc.BatchObjectsReply\"\x00Bj\n" +
+	"#io.weaviate.client.grpc.protocol.v0B\rWeaviateProtoZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var file_v0_weaviate_proto_goTypes = []any{
+	(*SearchRequest)(nil),       // 0: weaviategrpc.SearchRequest
+	(*BatchObjectsRequest)(nil), // 1: weaviategrpc.BatchObjectsRequest
+	(*SearchReply)(nil),         // 2: weaviategrpc.SearchReply
+	(*BatchObjectsReply)(nil),   // 3: weaviategrpc.BatchObjectsReply
+}
+var file_v0_weaviate_proto_depIdxs = []int32{
+	0, // 0: weaviategrpc.Weaviate.Search:input_type -> weaviategrpc.SearchRequest
+	1, // 1: weaviategrpc.Weaviate.BatchObjects:input_type -> weaviategrpc.BatchObjectsRequest
+	2, // 2: weaviategrpc.Weaviate.Search:output_type -> weaviategrpc.SearchReply
+	3, // 3: weaviategrpc.Weaviate.BatchObjects:output_type -> weaviategrpc.BatchObjectsReply
+	2, // [2:4] is the sub-list for method output_type
+	0, // [0:2] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_v0_weaviate_proto_init() }
+func file_v0_weaviate_proto_init() {
+	if File_v0_weaviate_proto != nil {
+		return
+	}
+	file_v0_batch_proto_init()
+	file_v0_search_get_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v0_weaviate_proto_rawDesc), len(file_v0_weaviate_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_v0_weaviate_proto_goTypes,
+		DependencyIndexes: file_v0_weaviate_proto_depIdxs,
+	}.Build()
+	File_v0_weaviate_proto = out.File
+	file_v0_weaviate_proto_goTypes = nil
+	file_v0_weaviate_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v0/weaviate_grpc.pb.go

@@ -0,0 +1,156 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+
+package protocol
+
+import (
+	context "context"
+
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Weaviate_Search_FullMethodName       = "/weaviategrpc.Weaviate/Search"
+	Weaviate_BatchObjects_FullMethodName = "/weaviategrpc.Weaviate/BatchObjects"
+)
+
+// WeaviateClient is the client API for Weaviate service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type WeaviateClient interface {
+	Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchReply, error)
+	BatchObjects(ctx context.Context, in *BatchObjectsRequest, opts ...grpc.CallOption) (*BatchObjectsReply, error)
+}
+
+type weaviateClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewWeaviateClient(cc grpc.ClientConnInterface) WeaviateClient {
+	return &weaviateClient{cc}
+}
+
+func (c *weaviateClient) Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchReply, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(SearchReply)
+	err := c.cc.Invoke(ctx, Weaviate_Search_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *weaviateClient) BatchObjects(ctx context.Context, in *BatchObjectsRequest, opts ...grpc.CallOption) (*BatchObjectsReply, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(BatchObjectsReply)
+	err := c.cc.Invoke(ctx, Weaviate_BatchObjects_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// WeaviateServer is the server API for Weaviate service.
+// All implementations must embed UnimplementedWeaviateServer
+// for forward compatibility.
+type WeaviateServer interface {
+	Search(context.Context, *SearchRequest) (*SearchReply, error)
+	BatchObjects(context.Context, *BatchObjectsRequest) (*BatchObjectsReply, error)
+	mustEmbedUnimplementedWeaviateServer()
+}
+
+// UnimplementedWeaviateServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedWeaviateServer struct{}
+
+func (UnimplementedWeaviateServer) Search(context.Context, *SearchRequest) (*SearchReply, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Search not implemented")
+}
+func (UnimplementedWeaviateServer) BatchObjects(context.Context, *BatchObjectsRequest) (*BatchObjectsReply, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method BatchObjects not implemented")
+}
+func (UnimplementedWeaviateServer) mustEmbedUnimplementedWeaviateServer() {}
+func (UnimplementedWeaviateServer) testEmbeddedByValue()                  {}
+
+// UnsafeWeaviateServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to WeaviateServer will
+// result in compilation errors.
+type UnsafeWeaviateServer interface {
+	mustEmbedUnimplementedWeaviateServer()
+}
+
+func RegisterWeaviateServer(s grpc.ServiceRegistrar, srv WeaviateServer) {
+	// If the following call pancis, it indicates UnimplementedWeaviateServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Weaviate_ServiceDesc, srv)
+}
+
+func _Weaviate_Search_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SearchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WeaviateServer).Search(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Weaviate_Search_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WeaviateServer).Search(ctx, req.(*SearchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Weaviate_BatchObjects_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(BatchObjectsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WeaviateServer).BatchObjects(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Weaviate_BatchObjects_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WeaviateServer).BatchObjects(ctx, req.(*BatchObjectsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Weaviate_ServiceDesc is the grpc.ServiceDesc for Weaviate service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Weaviate_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "weaviategrpc.Weaviate",
+	HandlerType: (*WeaviateServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Search",
+			Handler:    _Weaviate_Search_Handler,
+		},
+		{
+			MethodName: "BatchObjects",
+			Handler:    _Weaviate_BatchObjects_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "v0/weaviate.proto",
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/aggregate.pb.go

@@ -0,0 +1,2630 @@
+// 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"
+)
+
+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 AggregateRequest struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// required
+	Collection string `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
+	// parameters
+	Tenant string `protobuf:"bytes,10,opt,name=tenant,proto3" json:"tenant,omitempty"`
+	// what is returned
+	ObjectsCount bool                            `protobuf:"varint,20,opt,name=objects_count,json=objectsCount,proto3" json:"objects_count,omitempty"`
+	Aggregations []*AggregateRequest_Aggregation `protobuf:"bytes,21,rep,name=aggregations,proto3" json:"aggregations,omitempty"`
+	// affects aggregation results
+	ObjectLimit *uint32                   `protobuf:"varint,30,opt,name=object_limit,json=objectLimit,proto3,oneof" json:"object_limit,omitempty"`
+	GroupBy     *AggregateRequest_GroupBy `protobuf:"bytes,31,opt,name=group_by,json=groupBy,proto3,oneof" json:"group_by,omitempty"`
+	Limit       *uint32                   `protobuf:"varint,32,opt,name=limit,proto3,oneof" json:"limit,omitempty"`
+	// matches/searches for objects
+	Filters *Filters `protobuf:"bytes,40,opt,name=filters,proto3,oneof" json:"filters,omitempty"`
+	// Types that are valid to be assigned to Search:
+	//
+	//	*AggregateRequest_Hybrid
+	//	*AggregateRequest_NearVector
+	//	*AggregateRequest_NearObject
+	//	*AggregateRequest_NearText
+	//	*AggregateRequest_NearImage
+	//	*AggregateRequest_NearAudio
+	//	*AggregateRequest_NearVideo
+	//	*AggregateRequest_NearDepth
+	//	*AggregateRequest_NearThermal
+	//	*AggregateRequest_NearImu
+	Search        isAggregateRequest_Search `protobuf_oneof:"search"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest) Reset() {
+	*x = AggregateRequest{}
+	mi := &file_v1_aggregate_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest) ProtoMessage() {}
+
+func (x *AggregateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest.ProtoReflect.Descriptor instead.
+func (*AggregateRequest) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *AggregateRequest) GetCollection() string {
+	if x != nil {
+		return x.Collection
+	}
+	return ""
+}
+
+func (x *AggregateRequest) GetTenant() string {
+	if x != nil {
+		return x.Tenant
+	}
+	return ""
+}
+
+func (x *AggregateRequest) GetObjectsCount() bool {
+	if x != nil {
+		return x.ObjectsCount
+	}
+	return false
+}
+
+func (x *AggregateRequest) GetAggregations() []*AggregateRequest_Aggregation {
+	if x != nil {
+		return x.Aggregations
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetObjectLimit() uint32 {
+	if x != nil && x.ObjectLimit != nil {
+		return *x.ObjectLimit
+	}
+	return 0
+}
+
+func (x *AggregateRequest) GetGroupBy() *AggregateRequest_GroupBy {
+	if x != nil {
+		return x.GroupBy
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetLimit() uint32 {
+	if x != nil && x.Limit != nil {
+		return *x.Limit
+	}
+	return 0
+}
+
+func (x *AggregateRequest) GetFilters() *Filters {
+	if x != nil {
+		return x.Filters
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetSearch() isAggregateRequest_Search {
+	if x != nil {
+		return x.Search
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetHybrid() *Hybrid {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_Hybrid); ok {
+			return x.Hybrid
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearVector() *NearVector {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearVector); ok {
+			return x.NearVector
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearObject() *NearObject {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearObject); ok {
+			return x.NearObject
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearText() *NearTextSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearText); ok {
+			return x.NearText
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearImage() *NearImageSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearImage); ok {
+			return x.NearImage
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearAudio() *NearAudioSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearAudio); ok {
+			return x.NearAudio
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearVideo() *NearVideoSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearVideo); ok {
+			return x.NearVideo
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearDepth() *NearDepthSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearDepth); ok {
+			return x.NearDepth
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearThermal() *NearThermalSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearThermal); ok {
+			return x.NearThermal
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest) GetNearImu() *NearIMUSearch {
+	if x != nil {
+		if x, ok := x.Search.(*AggregateRequest_NearImu); ok {
+			return x.NearImu
+		}
+	}
+	return nil
+}
+
+type isAggregateRequest_Search interface {
+	isAggregateRequest_Search()
+}
+
+type AggregateRequest_Hybrid struct {
+	Hybrid *Hybrid `protobuf:"bytes,41,opt,name=hybrid,proto3,oneof"`
+}
+
+type AggregateRequest_NearVector struct {
+	NearVector *NearVector `protobuf:"bytes,42,opt,name=near_vector,json=nearVector,proto3,oneof"`
+}
+
+type AggregateRequest_NearObject struct {
+	NearObject *NearObject `protobuf:"bytes,43,opt,name=near_object,json=nearObject,proto3,oneof"`
+}
+
+type AggregateRequest_NearText struct {
+	NearText *NearTextSearch `protobuf:"bytes,44,opt,name=near_text,json=nearText,proto3,oneof"`
+}
+
+type AggregateRequest_NearImage struct {
+	NearImage *NearImageSearch `protobuf:"bytes,45,opt,name=near_image,json=nearImage,proto3,oneof"`
+}
+
+type AggregateRequest_NearAudio struct {
+	NearAudio *NearAudioSearch `protobuf:"bytes,46,opt,name=near_audio,json=nearAudio,proto3,oneof"`
+}
+
+type AggregateRequest_NearVideo struct {
+	NearVideo *NearVideoSearch `protobuf:"bytes,47,opt,name=near_video,json=nearVideo,proto3,oneof"`
+}
+
+type AggregateRequest_NearDepth struct {
+	NearDepth *NearDepthSearch `protobuf:"bytes,48,opt,name=near_depth,json=nearDepth,proto3,oneof"`
+}
+
+type AggregateRequest_NearThermal struct {
+	NearThermal *NearThermalSearch `protobuf:"bytes,49,opt,name=near_thermal,json=nearThermal,proto3,oneof"`
+}
+
+type AggregateRequest_NearImu struct {
+	NearImu *NearIMUSearch `protobuf:"bytes,50,opt,name=near_imu,json=nearImu,proto3,oneof"`
+}
+
+func (*AggregateRequest_Hybrid) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearVector) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearObject) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearText) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearImage) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearAudio) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearVideo) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearDepth) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearThermal) isAggregateRequest_Search() {}
+
+func (*AggregateRequest_NearImu) isAggregateRequest_Search() {}
+
+type AggregateReply struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Took  float32                `protobuf:"fixed32,1,opt,name=took,proto3" json:"took,omitempty"`
+	// Types that are valid to be assigned to Result:
+	//
+	//	*AggregateReply_SingleResult
+	//	*AggregateReply_GroupedResults
+	Result        isAggregateReply_Result `protobuf_oneof:"result"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply) Reset() {
+	*x = AggregateReply{}
+	mi := &file_v1_aggregate_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply) ProtoMessage() {}
+
+func (x *AggregateReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply.ProtoReflect.Descriptor instead.
+func (*AggregateReply) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *AggregateReply) GetTook() float32 {
+	if x != nil {
+		return x.Took
+	}
+	return 0
+}
+
+func (x *AggregateReply) GetResult() isAggregateReply_Result {
+	if x != nil {
+		return x.Result
+	}
+	return nil
+}
+
+func (x *AggregateReply) GetSingleResult() *AggregateReply_Single {
+	if x != nil {
+		if x, ok := x.Result.(*AggregateReply_SingleResult); ok {
+			return x.SingleResult
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply) GetGroupedResults() *AggregateReply_Grouped {
+	if x != nil {
+		if x, ok := x.Result.(*AggregateReply_GroupedResults); ok {
+			return x.GroupedResults
+		}
+	}
+	return nil
+}
+
+type isAggregateReply_Result interface {
+	isAggregateReply_Result()
+}
+
+type AggregateReply_SingleResult struct {
+	SingleResult *AggregateReply_Single `protobuf:"bytes,2,opt,name=single_result,json=singleResult,proto3,oneof"`
+}
+
+type AggregateReply_GroupedResults struct {
+	GroupedResults *AggregateReply_Grouped `protobuf:"bytes,3,opt,name=grouped_results,json=groupedResults,proto3,oneof"`
+}
+
+func (*AggregateReply_SingleResult) isAggregateReply_Result() {}
+
+func (*AggregateReply_GroupedResults) isAggregateReply_Result() {}
+
+type AggregateRequest_Aggregation struct {
+	state    protoimpl.MessageState `protogen:"open.v1"`
+	Property string                 `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"`
+	// Types that are valid to be assigned to Aggregation:
+	//
+	//	*AggregateRequest_Aggregation_Int
+	//	*AggregateRequest_Aggregation_Number_
+	//	*AggregateRequest_Aggregation_Text_
+	//	*AggregateRequest_Aggregation_Boolean_
+	//	*AggregateRequest_Aggregation_Date_
+	//	*AggregateRequest_Aggregation_Reference_
+	Aggregation   isAggregateRequest_Aggregation_Aggregation `protobuf_oneof:"aggregation"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation) Reset() {
+	*x = AggregateRequest_Aggregation{}
+	mi := &file_v1_aggregate_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *AggregateRequest_Aggregation) GetProperty() string {
+	if x != nil {
+		return x.Property
+	}
+	return ""
+}
+
+func (x *AggregateRequest_Aggregation) GetAggregation() isAggregateRequest_Aggregation_Aggregation {
+	if x != nil {
+		return x.Aggregation
+	}
+	return nil
+}
+
+func (x *AggregateRequest_Aggregation) GetInt() *AggregateRequest_Aggregation_Integer {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateRequest_Aggregation_Int); ok {
+			return x.Int
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest_Aggregation) GetNumber() *AggregateRequest_Aggregation_Number {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateRequest_Aggregation_Number_); ok {
+			return x.Number
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest_Aggregation) GetText() *AggregateRequest_Aggregation_Text {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateRequest_Aggregation_Text_); ok {
+			return x.Text
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest_Aggregation) GetBoolean() *AggregateRequest_Aggregation_Boolean {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateRequest_Aggregation_Boolean_); ok {
+			return x.Boolean
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest_Aggregation) GetDate() *AggregateRequest_Aggregation_Date {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateRequest_Aggregation_Date_); ok {
+			return x.Date
+		}
+	}
+	return nil
+}
+
+func (x *AggregateRequest_Aggregation) GetReference() *AggregateRequest_Aggregation_Reference {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateRequest_Aggregation_Reference_); ok {
+			return x.Reference
+		}
+	}
+	return nil
+}
+
+type isAggregateRequest_Aggregation_Aggregation interface {
+	isAggregateRequest_Aggregation_Aggregation()
+}
+
+type AggregateRequest_Aggregation_Int struct {
+	Int *AggregateRequest_Aggregation_Integer `protobuf:"bytes,2,opt,name=int,proto3,oneof"`
+}
+
+type AggregateRequest_Aggregation_Number_ struct {
+	Number *AggregateRequest_Aggregation_Number `protobuf:"bytes,3,opt,name=number,proto3,oneof"`
+}
+
+type AggregateRequest_Aggregation_Text_ struct {
+	Text *AggregateRequest_Aggregation_Text `protobuf:"bytes,4,opt,name=text,proto3,oneof"`
+}
+
+type AggregateRequest_Aggregation_Boolean_ struct {
+	Boolean *AggregateRequest_Aggregation_Boolean `protobuf:"bytes,5,opt,name=boolean,proto3,oneof"`
+}
+
+type AggregateRequest_Aggregation_Date_ struct {
+	Date *AggregateRequest_Aggregation_Date `protobuf:"bytes,6,opt,name=date,proto3,oneof"`
+}
+
+type AggregateRequest_Aggregation_Reference_ struct {
+	Reference *AggregateRequest_Aggregation_Reference `protobuf:"bytes,7,opt,name=reference,proto3,oneof"`
+}
+
+func (*AggregateRequest_Aggregation_Int) isAggregateRequest_Aggregation_Aggregation() {}
+
+func (*AggregateRequest_Aggregation_Number_) isAggregateRequest_Aggregation_Aggregation() {}
+
+func (*AggregateRequest_Aggregation_Text_) isAggregateRequest_Aggregation_Aggregation() {}
+
+func (*AggregateRequest_Aggregation_Boolean_) isAggregateRequest_Aggregation_Aggregation() {}
+
+func (*AggregateRequest_Aggregation_Date_) isAggregateRequest_Aggregation_Aggregation() {}
+
+func (*AggregateRequest_Aggregation_Reference_) isAggregateRequest_Aggregation_Aggregation() {}
+
+type AggregateRequest_GroupBy struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Collection    string                 `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
+	Property      string                 `protobuf:"bytes,2,opt,name=property,proto3" json:"property,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_GroupBy) Reset() {
+	*x = AggregateRequest_GroupBy{}
+	mi := &file_v1_aggregate_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_GroupBy) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_GroupBy) ProtoMessage() {}
+
+func (x *AggregateRequest_GroupBy) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_GroupBy.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_GroupBy) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 1}
+}
+
+func (x *AggregateRequest_GroupBy) GetCollection() string {
+	if x != nil {
+		return x.Collection
+	}
+	return ""
+}
+
+func (x *AggregateRequest_GroupBy) GetProperty() string {
+	if x != nil {
+		return x.Property
+	}
+	return ""
+}
+
+type AggregateRequest_Aggregation_Integer struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Count         bool                   `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Type          bool                   `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
+	Sum           bool                   `protobuf:"varint,3,opt,name=sum,proto3" json:"sum,omitempty"`
+	Mean          bool                   `protobuf:"varint,4,opt,name=mean,proto3" json:"mean,omitempty"`
+	Mode          bool                   `protobuf:"varint,5,opt,name=mode,proto3" json:"mode,omitempty"`
+	Median        bool                   `protobuf:"varint,6,opt,name=median,proto3" json:"median,omitempty"`
+	Maximum       bool                   `protobuf:"varint,7,opt,name=maximum,proto3" json:"maximum,omitempty"`
+	Minimum       bool                   `protobuf:"varint,8,opt,name=minimum,proto3" json:"minimum,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation_Integer) Reset() {
+	*x = AggregateRequest_Aggregation_Integer{}
+	mi := &file_v1_aggregate_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation_Integer) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation_Integer) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation_Integer) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation_Integer.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation_Integer) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0, 0}
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetCount() bool {
+	if x != nil {
+		return x.Count
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetType() bool {
+	if x != nil {
+		return x.Type
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetSum() bool {
+	if x != nil {
+		return x.Sum
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetMean() bool {
+	if x != nil {
+		return x.Mean
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetMode() bool {
+	if x != nil {
+		return x.Mode
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetMedian() bool {
+	if x != nil {
+		return x.Median
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetMaximum() bool {
+	if x != nil {
+		return x.Maximum
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Integer) GetMinimum() bool {
+	if x != nil {
+		return x.Minimum
+	}
+	return false
+}
+
+type AggregateRequest_Aggregation_Number struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Count         bool                   `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Type          bool                   `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
+	Sum           bool                   `protobuf:"varint,3,opt,name=sum,proto3" json:"sum,omitempty"`
+	Mean          bool                   `protobuf:"varint,4,opt,name=mean,proto3" json:"mean,omitempty"`
+	Mode          bool                   `protobuf:"varint,5,opt,name=mode,proto3" json:"mode,omitempty"`
+	Median        bool                   `protobuf:"varint,6,opt,name=median,proto3" json:"median,omitempty"`
+	Maximum       bool                   `protobuf:"varint,7,opt,name=maximum,proto3" json:"maximum,omitempty"`
+	Minimum       bool                   `protobuf:"varint,8,opt,name=minimum,proto3" json:"minimum,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation_Number) Reset() {
+	*x = AggregateRequest_Aggregation_Number{}
+	mi := &file_v1_aggregate_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation_Number) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation_Number) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation_Number) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation_Number.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation_Number) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0, 1}
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetCount() bool {
+	if x != nil {
+		return x.Count
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetType() bool {
+	if x != nil {
+		return x.Type
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetSum() bool {
+	if x != nil {
+		return x.Sum
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetMean() bool {
+	if x != nil {
+		return x.Mean
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetMode() bool {
+	if x != nil {
+		return x.Mode
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetMedian() bool {
+	if x != nil {
+		return x.Median
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetMaximum() bool {
+	if x != nil {
+		return x.Maximum
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Number) GetMinimum() bool {
+	if x != nil {
+		return x.Minimum
+	}
+	return false
+}
+
+type AggregateRequest_Aggregation_Text struct {
+	state              protoimpl.MessageState `protogen:"open.v1"`
+	Count              bool                   `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Type               bool                   `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
+	TopOccurences      bool                   `protobuf:"varint,3,opt,name=top_occurences,json=topOccurences,proto3" json:"top_occurences,omitempty"`
+	TopOccurencesLimit *uint32                `protobuf:"varint,4,opt,name=top_occurences_limit,json=topOccurencesLimit,proto3,oneof" json:"top_occurences_limit,omitempty"`
+	unknownFields      protoimpl.UnknownFields
+	sizeCache          protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation_Text) Reset() {
+	*x = AggregateRequest_Aggregation_Text{}
+	mi := &file_v1_aggregate_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation_Text) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation_Text) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation_Text) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation_Text.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation_Text) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0, 2}
+}
+
+func (x *AggregateRequest_Aggregation_Text) GetCount() bool {
+	if x != nil {
+		return x.Count
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Text) GetType() bool {
+	if x != nil {
+		return x.Type
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Text) GetTopOccurences() bool {
+	if x != nil {
+		return x.TopOccurences
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Text) GetTopOccurencesLimit() uint32 {
+	if x != nil && x.TopOccurencesLimit != nil {
+		return *x.TopOccurencesLimit
+	}
+	return 0
+}
+
+type AggregateRequest_Aggregation_Boolean struct {
+	state           protoimpl.MessageState `protogen:"open.v1"`
+	Count           bool                   `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Type            bool                   `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
+	TotalTrue       bool                   `protobuf:"varint,3,opt,name=total_true,json=totalTrue,proto3" json:"total_true,omitempty"`
+	TotalFalse      bool                   `protobuf:"varint,4,opt,name=total_false,json=totalFalse,proto3" json:"total_false,omitempty"`
+	PercentageTrue  bool                   `protobuf:"varint,5,opt,name=percentage_true,json=percentageTrue,proto3" json:"percentage_true,omitempty"`
+	PercentageFalse bool                   `protobuf:"varint,6,opt,name=percentage_false,json=percentageFalse,proto3" json:"percentage_false,omitempty"`
+	unknownFields   protoimpl.UnknownFields
+	sizeCache       protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) Reset() {
+	*x = AggregateRequest_Aggregation_Boolean{}
+	mi := &file_v1_aggregate_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation_Boolean) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation_Boolean) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation_Boolean.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation_Boolean) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0, 3}
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) GetCount() bool {
+	if x != nil {
+		return x.Count
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) GetType() bool {
+	if x != nil {
+		return x.Type
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) GetTotalTrue() bool {
+	if x != nil {
+		return x.TotalTrue
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) GetTotalFalse() bool {
+	if x != nil {
+		return x.TotalFalse
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) GetPercentageTrue() bool {
+	if x != nil {
+		return x.PercentageTrue
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Boolean) GetPercentageFalse() bool {
+	if x != nil {
+		return x.PercentageFalse
+	}
+	return false
+}
+
+type AggregateRequest_Aggregation_Date struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Count         bool                   `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Type          bool                   `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
+	Median        bool                   `protobuf:"varint,3,opt,name=median,proto3" json:"median,omitempty"`
+	Mode          bool                   `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
+	Maximum       bool                   `protobuf:"varint,5,opt,name=maximum,proto3" json:"maximum,omitempty"`
+	Minimum       bool                   `protobuf:"varint,6,opt,name=minimum,proto3" json:"minimum,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation_Date) Reset() {
+	*x = AggregateRequest_Aggregation_Date{}
+	mi := &file_v1_aggregate_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation_Date) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation_Date) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation_Date) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation_Date.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation_Date) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0, 4}
+}
+
+func (x *AggregateRequest_Aggregation_Date) GetCount() bool {
+	if x != nil {
+		return x.Count
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Date) GetType() bool {
+	if x != nil {
+		return x.Type
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Date) GetMedian() bool {
+	if x != nil {
+		return x.Median
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Date) GetMode() bool {
+	if x != nil {
+		return x.Mode
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Date) GetMaximum() bool {
+	if x != nil {
+		return x.Maximum
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Date) GetMinimum() bool {
+	if x != nil {
+		return x.Minimum
+	}
+	return false
+}
+
+type AggregateRequest_Aggregation_Reference struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Type          bool                   `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
+	PointingTo    bool                   `protobuf:"varint,2,opt,name=pointing_to,json=pointingTo,proto3" json:"pointing_to,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateRequest_Aggregation_Reference) Reset() {
+	*x = AggregateRequest_Aggregation_Reference{}
+	mi := &file_v1_aggregate_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateRequest_Aggregation_Reference) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateRequest_Aggregation_Reference) ProtoMessage() {}
+
+func (x *AggregateRequest_Aggregation_Reference) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateRequest_Aggregation_Reference.ProtoReflect.Descriptor instead.
+func (*AggregateRequest_Aggregation_Reference) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{0, 0, 5}
+}
+
+func (x *AggregateRequest_Aggregation_Reference) GetType() bool {
+	if x != nil {
+		return x.Type
+	}
+	return false
+}
+
+func (x *AggregateRequest_Aggregation_Reference) GetPointingTo() bool {
+	if x != nil {
+		return x.PointingTo
+	}
+	return false
+}
+
+type AggregateReply_Aggregations struct {
+	state         protoimpl.MessageState                     `protogen:"open.v1"`
+	Aggregations  []*AggregateReply_Aggregations_Aggregation `protobuf:"bytes,1,rep,name=aggregations,proto3" json:"aggregations,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations) Reset() {
+	*x = AggregateReply_Aggregations{}
+	mi := &file_v1_aggregate_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0}
+}
+
+func (x *AggregateReply_Aggregations) GetAggregations() []*AggregateReply_Aggregations_Aggregation {
+	if x != nil {
+		return x.Aggregations
+	}
+	return nil
+}
+
+type AggregateReply_Single struct {
+	state         protoimpl.MessageState       `protogen:"open.v1"`
+	ObjectsCount  *int64                       `protobuf:"varint,1,opt,name=objects_count,json=objectsCount,proto3,oneof" json:"objects_count,omitempty"`
+	Aggregations  *AggregateReply_Aggregations `protobuf:"bytes,2,opt,name=aggregations,proto3,oneof" json:"aggregations,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Single) Reset() {
+	*x = AggregateReply_Single{}
+	mi := &file_v1_aggregate_proto_msgTypes[11]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Single) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Single) ProtoMessage() {}
+
+func (x *AggregateReply_Single) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Single.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Single) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 1}
+}
+
+func (x *AggregateReply_Single) GetObjectsCount() int64 {
+	if x != nil && x.ObjectsCount != nil {
+		return *x.ObjectsCount
+	}
+	return 0
+}
+
+func (x *AggregateReply_Single) GetAggregations() *AggregateReply_Aggregations {
+	if x != nil {
+		return x.Aggregations
+	}
+	return nil
+}
+
+type AggregateReply_Group struct {
+	state         protoimpl.MessageState          `protogen:"open.v1"`
+	ObjectsCount  *int64                          `protobuf:"varint,1,opt,name=objects_count,json=objectsCount,proto3,oneof" json:"objects_count,omitempty"`
+	Aggregations  *AggregateReply_Aggregations    `protobuf:"bytes,2,opt,name=aggregations,proto3,oneof" json:"aggregations,omitempty"`
+	GroupedBy     *AggregateReply_Group_GroupedBy `protobuf:"bytes,3,opt,name=grouped_by,json=groupedBy,proto3,oneof" json:"grouped_by,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Group) Reset() {
+	*x = AggregateReply_Group{}
+	mi := &file_v1_aggregate_proto_msgTypes[12]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Group) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Group) ProtoMessage() {}
+
+func (x *AggregateReply_Group) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Group.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Group) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 2}
+}
+
+func (x *AggregateReply_Group) GetObjectsCount() int64 {
+	if x != nil && x.ObjectsCount != nil {
+		return *x.ObjectsCount
+	}
+	return 0
+}
+
+func (x *AggregateReply_Group) GetAggregations() *AggregateReply_Aggregations {
+	if x != nil {
+		return x.Aggregations
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group) GetGroupedBy() *AggregateReply_Group_GroupedBy {
+	if x != nil {
+		return x.GroupedBy
+	}
+	return nil
+}
+
+type AggregateReply_Grouped struct {
+	state         protoimpl.MessageState  `protogen:"open.v1"`
+	Groups        []*AggregateReply_Group `protobuf:"bytes,1,rep,name=groups,proto3" json:"groups,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Grouped) Reset() {
+	*x = AggregateReply_Grouped{}
+	mi := &file_v1_aggregate_proto_msgTypes[13]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Grouped) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Grouped) ProtoMessage() {}
+
+func (x *AggregateReply_Grouped) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Grouped.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Grouped) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 3}
+}
+
+func (x *AggregateReply_Grouped) GetGroups() []*AggregateReply_Group {
+	if x != nil {
+		return x.Groups
+	}
+	return nil
+}
+
+type AggregateReply_Aggregations_Aggregation struct {
+	state    protoimpl.MessageState `protogen:"open.v1"`
+	Property string                 `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"`
+	// Types that are valid to be assigned to Aggregation:
+	//
+	//	*AggregateReply_Aggregations_Aggregation_Int
+	//	*AggregateReply_Aggregations_Aggregation_Number_
+	//	*AggregateReply_Aggregations_Aggregation_Text_
+	//	*AggregateReply_Aggregations_Aggregation_Boolean_
+	//	*AggregateReply_Aggregations_Aggregation_Date_
+	//	*AggregateReply_Aggregations_Aggregation_Reference_
+	Aggregation   isAggregateReply_Aggregations_Aggregation_Aggregation `protobuf_oneof:"aggregation"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation{}
+	mi := &file_v1_aggregate_proto_msgTypes[14]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetProperty() string {
+	if x != nil {
+		return x.Property
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetAggregation() isAggregateReply_Aggregations_Aggregation_Aggregation {
+	if x != nil {
+		return x.Aggregation
+	}
+	return nil
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetInt() *AggregateReply_Aggregations_Aggregation_Integer {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateReply_Aggregations_Aggregation_Int); ok {
+			return x.Int
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetNumber() *AggregateReply_Aggregations_Aggregation_Number {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateReply_Aggregations_Aggregation_Number_); ok {
+			return x.Number
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetText() *AggregateReply_Aggregations_Aggregation_Text {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateReply_Aggregations_Aggregation_Text_); ok {
+			return x.Text
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetBoolean() *AggregateReply_Aggregations_Aggregation_Boolean {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateReply_Aggregations_Aggregation_Boolean_); ok {
+			return x.Boolean
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetDate() *AggregateReply_Aggregations_Aggregation_Date {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateReply_Aggregations_Aggregation_Date_); ok {
+			return x.Date
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Aggregations_Aggregation) GetReference() *AggregateReply_Aggregations_Aggregation_Reference {
+	if x != nil {
+		if x, ok := x.Aggregation.(*AggregateReply_Aggregations_Aggregation_Reference_); ok {
+			return x.Reference
+		}
+	}
+	return nil
+}
+
+type isAggregateReply_Aggregations_Aggregation_Aggregation interface {
+	isAggregateReply_Aggregations_Aggregation_Aggregation()
+}
+
+type AggregateReply_Aggregations_Aggregation_Int struct {
+	Int *AggregateReply_Aggregations_Aggregation_Integer `protobuf:"bytes,2,opt,name=int,proto3,oneof"`
+}
+
+type AggregateReply_Aggregations_Aggregation_Number_ struct {
+	Number *AggregateReply_Aggregations_Aggregation_Number `protobuf:"bytes,3,opt,name=number,proto3,oneof"`
+}
+
+type AggregateReply_Aggregations_Aggregation_Text_ struct {
+	Text *AggregateReply_Aggregations_Aggregation_Text `protobuf:"bytes,4,opt,name=text,proto3,oneof"`
+}
+
+type AggregateReply_Aggregations_Aggregation_Boolean_ struct {
+	Boolean *AggregateReply_Aggregations_Aggregation_Boolean `protobuf:"bytes,5,opt,name=boolean,proto3,oneof"`
+}
+
+type AggregateReply_Aggregations_Aggregation_Date_ struct {
+	Date *AggregateReply_Aggregations_Aggregation_Date `protobuf:"bytes,6,opt,name=date,proto3,oneof"`
+}
+
+type AggregateReply_Aggregations_Aggregation_Reference_ struct {
+	Reference *AggregateReply_Aggregations_Aggregation_Reference `protobuf:"bytes,7,opt,name=reference,proto3,oneof"`
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Int) isAggregateReply_Aggregations_Aggregation_Aggregation() {
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Number_) isAggregateReply_Aggregations_Aggregation_Aggregation() {
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Text_) isAggregateReply_Aggregations_Aggregation_Aggregation() {
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Boolean_) isAggregateReply_Aggregations_Aggregation_Aggregation() {
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Date_) isAggregateReply_Aggregations_Aggregation_Aggregation() {
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Reference_) isAggregateReply_Aggregations_Aggregation_Aggregation() {
+}
+
+type AggregateReply_Aggregations_Aggregation_Integer struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Count         *int64                 `protobuf:"varint,1,opt,name=count,proto3,oneof" json:"count,omitempty"`
+	Type          *string                `protobuf:"bytes,2,opt,name=type,proto3,oneof" json:"type,omitempty"`
+	Mean          *float64               `protobuf:"fixed64,3,opt,name=mean,proto3,oneof" json:"mean,omitempty"`
+	Median        *float64               `protobuf:"fixed64,4,opt,name=median,proto3,oneof" json:"median,omitempty"`
+	Mode          *int64                 `protobuf:"varint,5,opt,name=mode,proto3,oneof" json:"mode,omitempty"`
+	Maximum       *int64                 `protobuf:"varint,6,opt,name=maximum,proto3,oneof" json:"maximum,omitempty"`
+	Minimum       *int64                 `protobuf:"varint,7,opt,name=minimum,proto3,oneof" json:"minimum,omitempty"`
+	Sum           *int64                 `protobuf:"varint,8,opt,name=sum,proto3,oneof" json:"sum,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Integer{}
+	mi := &file_v1_aggregate_proto_msgTypes[15]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Integer) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Integer.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Integer) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 0}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetCount() int64 {
+	if x != nil && x.Count != nil {
+		return *x.Count
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetMean() float64 {
+	if x != nil && x.Mean != nil {
+		return *x.Mean
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetMedian() float64 {
+	if x != nil && x.Median != nil {
+		return *x.Median
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetMode() int64 {
+	if x != nil && x.Mode != nil {
+		return *x.Mode
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetMaximum() int64 {
+	if x != nil && x.Maximum != nil {
+		return *x.Maximum
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetMinimum() int64 {
+	if x != nil && x.Minimum != nil {
+		return *x.Minimum
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Integer) GetSum() int64 {
+	if x != nil && x.Sum != nil {
+		return *x.Sum
+	}
+	return 0
+}
+
+type AggregateReply_Aggregations_Aggregation_Number struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Count         *int64                 `protobuf:"varint,1,opt,name=count,proto3,oneof" json:"count,omitempty"`
+	Type          *string                `protobuf:"bytes,2,opt,name=type,proto3,oneof" json:"type,omitempty"`
+	Mean          *float64               `protobuf:"fixed64,3,opt,name=mean,proto3,oneof" json:"mean,omitempty"`
+	Median        *float64               `protobuf:"fixed64,4,opt,name=median,proto3,oneof" json:"median,omitempty"`
+	Mode          *float64               `protobuf:"fixed64,5,opt,name=mode,proto3,oneof" json:"mode,omitempty"`
+	Maximum       *float64               `protobuf:"fixed64,6,opt,name=maximum,proto3,oneof" json:"maximum,omitempty"`
+	Minimum       *float64               `protobuf:"fixed64,7,opt,name=minimum,proto3,oneof" json:"minimum,omitempty"`
+	Sum           *float64               `protobuf:"fixed64,8,opt,name=sum,proto3,oneof" json:"sum,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Number{}
+	mi := &file_v1_aggregate_proto_msgTypes[16]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Number) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Number.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Number) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 1}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetCount() int64 {
+	if x != nil && x.Count != nil {
+		return *x.Count
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetMean() float64 {
+	if x != nil && x.Mean != nil {
+		return *x.Mean
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetMedian() float64 {
+	if x != nil && x.Median != nil {
+		return *x.Median
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetMode() float64 {
+	if x != nil && x.Mode != nil {
+		return *x.Mode
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetMaximum() float64 {
+	if x != nil && x.Maximum != nil {
+		return *x.Maximum
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetMinimum() float64 {
+	if x != nil && x.Minimum != nil {
+		return *x.Minimum
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Number) GetSum() float64 {
+	if x != nil && x.Sum != nil {
+		return *x.Sum
+	}
+	return 0
+}
+
+type AggregateReply_Aggregations_Aggregation_Text struct {
+	state         protoimpl.MessageState                                       `protogen:"open.v1"`
+	Count         *int64                                                       `protobuf:"varint,1,opt,name=count,proto3,oneof" json:"count,omitempty"`
+	Type          *string                                                      `protobuf:"bytes,2,opt,name=type,proto3,oneof" json:"type,omitempty"`
+	TopOccurences *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences `protobuf:"bytes,3,opt,name=top_occurences,json=topOccurences,proto3,oneof" json:"top_occurences,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Text{}
+	mi := &file_v1_aggregate_proto_msgTypes[17]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Text) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Text.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Text) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 2}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text) GetCount() int64 {
+	if x != nil && x.Count != nil {
+		return *x.Count
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text) GetTopOccurences() *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences {
+	if x != nil {
+		return x.TopOccurences
+	}
+	return nil
+}
+
+type AggregateReply_Aggregations_Aggregation_Boolean struct {
+	state           protoimpl.MessageState `protogen:"open.v1"`
+	Count           *int64                 `protobuf:"varint,1,opt,name=count,proto3,oneof" json:"count,omitempty"`
+	Type            *string                `protobuf:"bytes,2,opt,name=type,proto3,oneof" json:"type,omitempty"`
+	TotalTrue       *int64                 `protobuf:"varint,3,opt,name=total_true,json=totalTrue,proto3,oneof" json:"total_true,omitempty"`
+	TotalFalse      *int64                 `protobuf:"varint,4,opt,name=total_false,json=totalFalse,proto3,oneof" json:"total_false,omitempty"`
+	PercentageTrue  *float64               `protobuf:"fixed64,5,opt,name=percentage_true,json=percentageTrue,proto3,oneof" json:"percentage_true,omitempty"`
+	PercentageFalse *float64               `protobuf:"fixed64,6,opt,name=percentage_false,json=percentageFalse,proto3,oneof" json:"percentage_false,omitempty"`
+	unknownFields   protoimpl.UnknownFields
+	sizeCache       protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Boolean{}
+	mi := &file_v1_aggregate_proto_msgTypes[18]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Boolean) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Boolean.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Boolean) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 3}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) GetCount() int64 {
+	if x != nil && x.Count != nil {
+		return *x.Count
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) GetTotalTrue() int64 {
+	if x != nil && x.TotalTrue != nil {
+		return *x.TotalTrue
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) GetTotalFalse() int64 {
+	if x != nil && x.TotalFalse != nil {
+		return *x.TotalFalse
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) GetPercentageTrue() float64 {
+	if x != nil && x.PercentageTrue != nil {
+		return *x.PercentageTrue
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Boolean) GetPercentageFalse() float64 {
+	if x != nil && x.PercentageFalse != nil {
+		return *x.PercentageFalse
+	}
+	return 0
+}
+
+type AggregateReply_Aggregations_Aggregation_Date struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Count         *int64                 `protobuf:"varint,1,opt,name=count,proto3,oneof" json:"count,omitempty"`
+	Type          *string                `protobuf:"bytes,2,opt,name=type,proto3,oneof" json:"type,omitempty"`
+	Median        *string                `protobuf:"bytes,3,opt,name=median,proto3,oneof" json:"median,omitempty"`
+	Mode          *string                `protobuf:"bytes,4,opt,name=mode,proto3,oneof" json:"mode,omitempty"`
+	Maximum       *string                `protobuf:"bytes,5,opt,name=maximum,proto3,oneof" json:"maximum,omitempty"`
+	Minimum       *string                `protobuf:"bytes,6,opt,name=minimum,proto3,oneof" json:"minimum,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Date{}
+	mi := &file_v1_aggregate_proto_msgTypes[19]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Date) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Date.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Date) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 4}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) GetCount() int64 {
+	if x != nil && x.Count != nil {
+		return *x.Count
+	}
+	return 0
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) GetMedian() string {
+	if x != nil && x.Median != nil {
+		return *x.Median
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) GetMode() string {
+	if x != nil && x.Mode != nil {
+		return *x.Mode
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) GetMaximum() string {
+	if x != nil && x.Maximum != nil {
+		return *x.Maximum
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Date) GetMinimum() string {
+	if x != nil && x.Minimum != nil {
+		return *x.Minimum
+	}
+	return ""
+}
+
+type AggregateReply_Aggregations_Aggregation_Reference struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Type  *string                `protobuf:"bytes,1,opt,name=type,proto3,oneof" json:"type,omitempty"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	PointingTo    []string `protobuf:"bytes,2,rep,name=pointing_to,json=pointingTo,proto3" json:"pointing_to,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Reference) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Reference{}
+	mi := &file_v1_aggregate_proto_msgTypes[20]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Reference) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Reference) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Reference) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Reference.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Reference) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 5}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Reference) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Reference) GetPointingTo() []string {
+	if x != nil {
+		return x.PointingTo
+	}
+	return nil
+}
+
+type AggregateReply_Aggregations_Aggregation_Text_TopOccurrences struct {
+	state         protoimpl.MessageState                                                       `protogen:"open.v1"`
+	Items         []*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Text_TopOccurrences{}
+	mi := &file_v1_aggregate_proto_msgTypes[21]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Text_TopOccurrences.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 2, 0}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences) GetItems() []*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence {
+	if x != nil {
+		return x.Items
+	}
+	return nil
+}
+
+type AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Value         string                 `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+	Occurs        int64                  `protobuf:"varint,2,opt,name=occurs,proto3" json:"occurs,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) Reset() {
+	*x = AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence{}
+	mi := &file_v1_aggregate_proto_msgTypes[22]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) ProtoMessage() {}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 0, 0, 2, 0, 0}
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) GetValue() string {
+	if x != nil {
+		return x.Value
+	}
+	return ""
+}
+
+func (x *AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence) GetOccurs() int64 {
+	if x != nil {
+		return x.Occurs
+	}
+	return 0
+}
+
+type AggregateReply_Group_GroupedBy struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	Path []string `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
+	// Types that are valid to be assigned to Value:
+	//
+	//	*AggregateReply_Group_GroupedBy_Text
+	//	*AggregateReply_Group_GroupedBy_Int
+	//	*AggregateReply_Group_GroupedBy_Boolean
+	//	*AggregateReply_Group_GroupedBy_Number
+	//	*AggregateReply_Group_GroupedBy_Texts
+	//	*AggregateReply_Group_GroupedBy_Ints
+	//	*AggregateReply_Group_GroupedBy_Booleans
+	//	*AggregateReply_Group_GroupedBy_Numbers
+	//	*AggregateReply_Group_GroupedBy_Geo
+	Value         isAggregateReply_Group_GroupedBy_Value `protobuf_oneof:"value"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AggregateReply_Group_GroupedBy) Reset() {
+	*x = AggregateReply_Group_GroupedBy{}
+	mi := &file_v1_aggregate_proto_msgTypes[23]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AggregateReply_Group_GroupedBy) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AggregateReply_Group_GroupedBy) ProtoMessage() {}
+
+func (x *AggregateReply_Group_GroupedBy) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_aggregate_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 AggregateReply_Group_GroupedBy.ProtoReflect.Descriptor instead.
+func (*AggregateReply_Group_GroupedBy) Descriptor() ([]byte, []int) {
+	return file_v1_aggregate_proto_rawDescGZIP(), []int{1, 2, 0}
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetPath() []string {
+	if x != nil {
+		return x.Path
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetValue() isAggregateReply_Group_GroupedBy_Value {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetText() string {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Text); ok {
+			return x.Text
+		}
+	}
+	return ""
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetInt() int64 {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Int); ok {
+			return x.Int
+		}
+	}
+	return 0
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetBoolean() bool {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Boolean); ok {
+			return x.Boolean
+		}
+	}
+	return false
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetNumber() float64 {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Number); ok {
+			return x.Number
+		}
+	}
+	return 0
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetTexts() *TextArray {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Texts); ok {
+			return x.Texts
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetInts() *IntArray {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Ints); ok {
+			return x.Ints
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetBooleans() *BooleanArray {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Booleans); ok {
+			return x.Booleans
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetNumbers() *NumberArray {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Numbers); ok {
+			return x.Numbers
+		}
+	}
+	return nil
+}
+
+func (x *AggregateReply_Group_GroupedBy) GetGeo() *GeoCoordinatesFilter {
+	if x != nil {
+		if x, ok := x.Value.(*AggregateReply_Group_GroupedBy_Geo); ok {
+			return x.Geo
+		}
+	}
+	return nil
+}
+
+type isAggregateReply_Group_GroupedBy_Value interface {
+	isAggregateReply_Group_GroupedBy_Value()
+}
+
+type AggregateReply_Group_GroupedBy_Text struct {
+	Text string `protobuf:"bytes,2,opt,name=text,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Int struct {
+	Int int64 `protobuf:"varint,3,opt,name=int,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Boolean struct {
+	Boolean bool `protobuf:"varint,4,opt,name=boolean,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Number struct {
+	Number float64 `protobuf:"fixed64,5,opt,name=number,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Texts struct {
+	Texts *TextArray `protobuf:"bytes,6,opt,name=texts,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Ints struct {
+	Ints *IntArray `protobuf:"bytes,7,opt,name=ints,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Booleans struct {
+	Booleans *BooleanArray `protobuf:"bytes,8,opt,name=booleans,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Numbers struct {
+	Numbers *NumberArray `protobuf:"bytes,9,opt,name=numbers,proto3,oneof"`
+}
+
+type AggregateReply_Group_GroupedBy_Geo struct {
+	Geo *GeoCoordinatesFilter `protobuf:"bytes,10,opt,name=geo,proto3,oneof"`
+}
+
+func (*AggregateReply_Group_GroupedBy_Text) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Int) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Boolean) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Number) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Texts) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Ints) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Booleans) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Numbers) isAggregateReply_Group_GroupedBy_Value() {}
+
+func (*AggregateReply_Group_GroupedBy_Geo) isAggregateReply_Group_GroupedBy_Value() {}
+
+var File_v1_aggregate_proto protoreflect.FileDescriptor
+
+const file_v1_aggregate_proto_rawDesc = "" +
+	"\n" +
+	"\x12v1/aggregate.proto\x12\vweaviate.v1\x1a\rv1/base.proto\x1a\x14v1/base_search.proto\"\x9d\x14\n" +
+	"\x10AggregateRequest\x12\x1e\n" +
+	"\n" +
+	"collection\x18\x01 \x01(\tR\n" +
+	"collection\x12\x16\n" +
+	"\x06tenant\x18\n" +
+	" \x01(\tR\x06tenant\x12#\n" +
+	"\robjects_count\x18\x14 \x01(\bR\fobjectsCount\x12M\n" +
+	"\faggregations\x18\x15 \x03(\v2).weaviate.v1.AggregateRequest.AggregationR\faggregations\x12&\n" +
+	"\fobject_limit\x18\x1e \x01(\rH\x01R\vobjectLimit\x88\x01\x01\x12E\n" +
+	"\bgroup_by\x18\x1f \x01(\v2%.weaviate.v1.AggregateRequest.GroupByH\x02R\agroupBy\x88\x01\x01\x12\x19\n" +
+	"\x05limit\x18  \x01(\rH\x03R\x05limit\x88\x01\x01\x123\n" +
+	"\afilters\x18( \x01(\v2\x14.weaviate.v1.FiltersH\x04R\afilters\x88\x01\x01\x12-\n" +
+	"\x06hybrid\x18) \x01(\v2\x13.weaviate.v1.HybridH\x00R\x06hybrid\x12:\n" +
+	"\vnear_vector\x18* \x01(\v2\x17.weaviate.v1.NearVectorH\x00R\n" +
+	"nearVector\x12:\n" +
+	"\vnear_object\x18+ \x01(\v2\x17.weaviate.v1.NearObjectH\x00R\n" +
+	"nearObject\x12:\n" +
+	"\tnear_text\x18, \x01(\v2\x1b.weaviate.v1.NearTextSearchH\x00R\bnearText\x12=\n" +
+	"\n" +
+	"near_image\x18- \x01(\v2\x1c.weaviate.v1.NearImageSearchH\x00R\tnearImage\x12=\n" +
+	"\n" +
+	"near_audio\x18. \x01(\v2\x1c.weaviate.v1.NearAudioSearchH\x00R\tnearAudio\x12=\n" +
+	"\n" +
+	"near_video\x18/ \x01(\v2\x1c.weaviate.v1.NearVideoSearchH\x00R\tnearVideo\x12=\n" +
+	"\n" +
+	"near_depth\x180 \x01(\v2\x1c.weaviate.v1.NearDepthSearchH\x00R\tnearDepth\x12C\n" +
+	"\fnear_thermal\x181 \x01(\v2\x1e.weaviate.v1.NearThermalSearchH\x00R\vnearThermal\x127\n" +
+	"\bnear_imu\x182 \x01(\v2\x1a.weaviate.v1.NearIMUSearchH\x00R\anearImu\x1a\xbb\v\n" +
+	"\vAggregation\x12\x1a\n" +
+	"\bproperty\x18\x01 \x01(\tR\bproperty\x12E\n" +
+	"\x03int\x18\x02 \x01(\v21.weaviate.v1.AggregateRequest.Aggregation.IntegerH\x00R\x03int\x12J\n" +
+	"\x06number\x18\x03 \x01(\v20.weaviate.v1.AggregateRequest.Aggregation.NumberH\x00R\x06number\x12D\n" +
+	"\x04text\x18\x04 \x01(\v2..weaviate.v1.AggregateRequest.Aggregation.TextH\x00R\x04text\x12M\n" +
+	"\aboolean\x18\x05 \x01(\v21.weaviate.v1.AggregateRequest.Aggregation.BooleanH\x00R\aboolean\x12D\n" +
+	"\x04date\x18\x06 \x01(\v2..weaviate.v1.AggregateRequest.Aggregation.DateH\x00R\x04date\x12S\n" +
+	"\treference\x18\a \x01(\v23.weaviate.v1.AggregateRequest.Aggregation.ReferenceH\x00R\treference\x1a\xb9\x01\n" +
+	"\aInteger\x12\x14\n" +
+	"\x05count\x18\x01 \x01(\bR\x05count\x12\x12\n" +
+	"\x04type\x18\x02 \x01(\bR\x04type\x12\x10\n" +
+	"\x03sum\x18\x03 \x01(\bR\x03sum\x12\x12\n" +
+	"\x04mean\x18\x04 \x01(\bR\x04mean\x12\x12\n" +
+	"\x04mode\x18\x05 \x01(\bR\x04mode\x12\x16\n" +
+	"\x06median\x18\x06 \x01(\bR\x06median\x12\x18\n" +
+	"\amaximum\x18\a \x01(\bR\amaximum\x12\x18\n" +
+	"\aminimum\x18\b \x01(\bR\aminimum\x1a\xb8\x01\n" +
+	"\x06Number\x12\x14\n" +
+	"\x05count\x18\x01 \x01(\bR\x05count\x12\x12\n" +
+	"\x04type\x18\x02 \x01(\bR\x04type\x12\x10\n" +
+	"\x03sum\x18\x03 \x01(\bR\x03sum\x12\x12\n" +
+	"\x04mean\x18\x04 \x01(\bR\x04mean\x12\x12\n" +
+	"\x04mode\x18\x05 \x01(\bR\x04mode\x12\x16\n" +
+	"\x06median\x18\x06 \x01(\bR\x06median\x12\x18\n" +
+	"\amaximum\x18\a \x01(\bR\amaximum\x12\x18\n" +
+	"\aminimum\x18\b \x01(\bR\aminimum\x1a\xa7\x01\n" +
+	"\x04Text\x12\x14\n" +
+	"\x05count\x18\x01 \x01(\bR\x05count\x12\x12\n" +
+	"\x04type\x18\x02 \x01(\bR\x04type\x12%\n" +
+	"\x0etop_occurences\x18\x03 \x01(\bR\rtopOccurences\x125\n" +
+	"\x14top_occurences_limit\x18\x04 \x01(\rH\x00R\x12topOccurencesLimit\x88\x01\x01B\x17\n" +
+	"\x15_top_occurences_limit\x1a\xc7\x01\n" +
+	"\aBoolean\x12\x14\n" +
+	"\x05count\x18\x01 \x01(\bR\x05count\x12\x12\n" +
+	"\x04type\x18\x02 \x01(\bR\x04type\x12\x1d\n" +
+	"\n" +
+	"total_true\x18\x03 \x01(\bR\ttotalTrue\x12\x1f\n" +
+	"\vtotal_false\x18\x04 \x01(\bR\n" +
+	"totalFalse\x12'\n" +
+	"\x0fpercentage_true\x18\x05 \x01(\bR\x0epercentageTrue\x12)\n" +
+	"\x10percentage_false\x18\x06 \x01(\bR\x0fpercentageFalse\x1a\x90\x01\n" +
+	"\x04Date\x12\x14\n" +
+	"\x05count\x18\x01 \x01(\bR\x05count\x12\x12\n" +
+	"\x04type\x18\x02 \x01(\bR\x04type\x12\x16\n" +
+	"\x06median\x18\x03 \x01(\bR\x06median\x12\x12\n" +
+	"\x04mode\x18\x04 \x01(\bR\x04mode\x12\x18\n" +
+	"\amaximum\x18\x05 \x01(\bR\amaximum\x12\x18\n" +
+	"\aminimum\x18\x06 \x01(\bR\aminimum\x1a@\n" +
+	"\tReference\x12\x12\n" +
+	"\x04type\x18\x01 \x01(\bR\x04type\x12\x1f\n" +
+	"\vpointing_to\x18\x02 \x01(\bR\n" +
+	"pointingToB\r\n" +
+	"\vaggregation\x1aE\n" +
+	"\aGroupBy\x12\x1e\n" +
+	"\n" +
+	"collection\x18\x01 \x01(\tR\n" +
+	"collection\x12\x1a\n" +
+	"\bproperty\x18\x02 \x01(\tR\bpropertyB\b\n" +
+	"\x06searchB\x0f\n" +
+	"\r_object_limitB\v\n" +
+	"\t_group_byB\b\n" +
+	"\x06_limitB\n" +
+	"\n" +
+	"\b_filters\"\x80\x1b\n" +
+	"\x0eAggregateReply\x12\x12\n" +
+	"\x04took\x18\x01 \x01(\x02R\x04took\x12I\n" +
+	"\rsingle_result\x18\x02 \x01(\v2\".weaviate.v1.AggregateReply.SingleH\x00R\fsingleResult\x12N\n" +
+	"\x0fgrouped_results\x18\x03 \x01(\v2#.weaviate.v1.AggregateReply.GroupedH\x00R\x0egroupedResults\x1a\xab\x12\n" +
+	"\fAggregations\x12X\n" +
+	"\faggregations\x18\x01 \x03(\v24.weaviate.v1.AggregateReply.Aggregations.AggregationR\faggregations\x1a\xc0\x11\n" +
+	"\vAggregation\x12\x1a\n" +
+	"\bproperty\x18\x01 \x01(\tR\bproperty\x12P\n" +
+	"\x03int\x18\x02 \x01(\v2<.weaviate.v1.AggregateReply.Aggregations.Aggregation.IntegerH\x00R\x03int\x12U\n" +
+	"\x06number\x18\x03 \x01(\v2;.weaviate.v1.AggregateReply.Aggregations.Aggregation.NumberH\x00R\x06number\x12O\n" +
+	"\x04text\x18\x04 \x01(\v29.weaviate.v1.AggregateReply.Aggregations.Aggregation.TextH\x00R\x04text\x12X\n" +
+	"\aboolean\x18\x05 \x01(\v2<.weaviate.v1.AggregateReply.Aggregations.Aggregation.BooleanH\x00R\aboolean\x12O\n" +
+	"\x04date\x18\x06 \x01(\v29.weaviate.v1.AggregateReply.Aggregations.Aggregation.DateH\x00R\x04date\x12^\n" +
+	"\treference\x18\a \x01(\v2>.weaviate.v1.AggregateReply.Aggregations.Aggregation.ReferenceH\x00R\treference\x1a\xb1\x02\n" +
+	"\aInteger\x12\x19\n" +
+	"\x05count\x18\x01 \x01(\x03H\x00R\x05count\x88\x01\x01\x12\x17\n" +
+	"\x04type\x18\x02 \x01(\tH\x01R\x04type\x88\x01\x01\x12\x17\n" +
+	"\x04mean\x18\x03 \x01(\x01H\x02R\x04mean\x88\x01\x01\x12\x1b\n" +
+	"\x06median\x18\x04 \x01(\x01H\x03R\x06median\x88\x01\x01\x12\x17\n" +
+	"\x04mode\x18\x05 \x01(\x03H\x04R\x04mode\x88\x01\x01\x12\x1d\n" +
+	"\amaximum\x18\x06 \x01(\x03H\x05R\amaximum\x88\x01\x01\x12\x1d\n" +
+	"\aminimum\x18\a \x01(\x03H\x06R\aminimum\x88\x01\x01\x12\x15\n" +
+	"\x03sum\x18\b \x01(\x03H\aR\x03sum\x88\x01\x01B\b\n" +
+	"\x06_countB\a\n" +
+	"\x05_typeB\a\n" +
+	"\x05_meanB\t\n" +
+	"\a_medianB\a\n" +
+	"\x05_modeB\n" +
+	"\n" +
+	"\b_maximumB\n" +
+	"\n" +
+	"\b_minimumB\x06\n" +
+	"\x04_sum\x1a\xb0\x02\n" +
+	"\x06Number\x12\x19\n" +
+	"\x05count\x18\x01 \x01(\x03H\x00R\x05count\x88\x01\x01\x12\x17\n" +
+	"\x04type\x18\x02 \x01(\tH\x01R\x04type\x88\x01\x01\x12\x17\n" +
+	"\x04mean\x18\x03 \x01(\x01H\x02R\x04mean\x88\x01\x01\x12\x1b\n" +
+	"\x06median\x18\x04 \x01(\x01H\x03R\x06median\x88\x01\x01\x12\x17\n" +
+	"\x04mode\x18\x05 \x01(\x01H\x04R\x04mode\x88\x01\x01\x12\x1d\n" +
+	"\amaximum\x18\x06 \x01(\x01H\x05R\amaximum\x88\x01\x01\x12\x1d\n" +
+	"\aminimum\x18\a \x01(\x01H\x06R\aminimum\x88\x01\x01\x12\x15\n" +
+	"\x03sum\x18\b \x01(\x01H\aR\x03sum\x88\x01\x01B\b\n" +
+	"\x06_countB\a\n" +
+	"\x05_typeB\a\n" +
+	"\x05_meanB\t\n" +
+	"\a_medianB\a\n" +
+	"\x05_modeB\n" +
+	"\n" +
+	"\b_maximumB\n" +
+	"\n" +
+	"\b_minimumB\x06\n" +
+	"\x04_sum\x1a\x96\x03\n" +
+	"\x04Text\x12\x19\n" +
+	"\x05count\x18\x01 \x01(\x03H\x00R\x05count\x88\x01\x01\x12\x17\n" +
+	"\x04type\x18\x02 \x01(\tH\x01R\x04type\x88\x01\x01\x12t\n" +
+	"\x0etop_occurences\x18\x03 \x01(\v2H.weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesH\x02R\rtopOccurences\x88\x01\x01\x1a\xbd\x01\n" +
+	"\x0eTopOccurrences\x12l\n" +
+	"\x05items\x18\x01 \x03(\v2V.weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceR\x05items\x1a=\n" +
+	"\rTopOccurrence\x12\x14\n" +
+	"\x05value\x18\x01 \x01(\tR\x05value\x12\x16\n" +
+	"\x06occurs\x18\x02 \x01(\x03R\x06occursB\b\n" +
+	"\x06_countB\a\n" +
+	"\x05_typeB\x11\n" +
+	"\x0f_top_occurences\x1a\xc0\x02\n" +
+	"\aBoolean\x12\x19\n" +
+	"\x05count\x18\x01 \x01(\x03H\x00R\x05count\x88\x01\x01\x12\x17\n" +
+	"\x04type\x18\x02 \x01(\tH\x01R\x04type\x88\x01\x01\x12\"\n" +
+	"\n" +
+	"total_true\x18\x03 \x01(\x03H\x02R\ttotalTrue\x88\x01\x01\x12$\n" +
+	"\vtotal_false\x18\x04 \x01(\x03H\x03R\n" +
+	"totalFalse\x88\x01\x01\x12,\n" +
+	"\x0fpercentage_true\x18\x05 \x01(\x01H\x04R\x0epercentageTrue\x88\x01\x01\x12.\n" +
+	"\x10percentage_false\x18\x06 \x01(\x01H\x05R\x0fpercentageFalse\x88\x01\x01B\b\n" +
+	"\x06_countB\a\n" +
+	"\x05_typeB\r\n" +
+	"\v_total_trueB\x0e\n" +
+	"\f_total_falseB\x12\n" +
+	"\x10_percentage_trueB\x13\n" +
+	"\x11_percentage_false\x1a\xed\x01\n" +
+	"\x04Date\x12\x19\n" +
+	"\x05count\x18\x01 \x01(\x03H\x00R\x05count\x88\x01\x01\x12\x17\n" +
+	"\x04type\x18\x02 \x01(\tH\x01R\x04type\x88\x01\x01\x12\x1b\n" +
+	"\x06median\x18\x03 \x01(\tH\x02R\x06median\x88\x01\x01\x12\x17\n" +
+	"\x04mode\x18\x04 \x01(\tH\x03R\x04mode\x88\x01\x01\x12\x1d\n" +
+	"\amaximum\x18\x05 \x01(\tH\x04R\amaximum\x88\x01\x01\x12\x1d\n" +
+	"\aminimum\x18\x06 \x01(\tH\x05R\aminimum\x88\x01\x01B\b\n" +
+	"\x06_countB\a\n" +
+	"\x05_typeB\t\n" +
+	"\a_medianB\a\n" +
+	"\x05_modeB\n" +
+	"\n" +
+	"\b_maximumB\n" +
+	"\n" +
+	"\b_minimum\x1aN\n" +
+	"\tReference\x12\x17\n" +
+	"\x04type\x18\x01 \x01(\tH\x00R\x04type\x88\x01\x01\x12\x1f\n" +
+	"\vpointing_to\x18\x02 \x03(\tR\n" +
+	"pointingToB\a\n" +
+	"\x05_typeB\r\n" +
+	"\vaggregation\x1a\xa8\x01\n" +
+	"\x06Single\x12(\n" +
+	"\robjects_count\x18\x01 \x01(\x03H\x00R\fobjectsCount\x88\x01\x01\x12Q\n" +
+	"\faggregations\x18\x02 \x01(\v2(.weaviate.v1.AggregateReply.AggregationsH\x01R\faggregations\x88\x01\x01B\x10\n" +
+	"\x0e_objects_countB\x0f\n" +
+	"\r_aggregations\x1a\x95\x05\n" +
+	"\x05Group\x12(\n" +
+	"\robjects_count\x18\x01 \x01(\x03H\x00R\fobjectsCount\x88\x01\x01\x12Q\n" +
+	"\faggregations\x18\x02 \x01(\v2(.weaviate.v1.AggregateReply.AggregationsH\x01R\faggregations\x88\x01\x01\x12O\n" +
+	"\n" +
+	"grouped_by\x18\x03 \x01(\v2+.weaviate.v1.AggregateReply.Group.GroupedByH\x02R\tgroupedBy\x88\x01\x01\x1a\x8b\x03\n" +
+	"\tGroupedBy\x12\x12\n" +
+	"\x04path\x18\x01 \x03(\tR\x04path\x12\x14\n" +
+	"\x04text\x18\x02 \x01(\tH\x00R\x04text\x12\x12\n" +
+	"\x03int\x18\x03 \x01(\x03H\x00R\x03int\x12\x1a\n" +
+	"\aboolean\x18\x04 \x01(\bH\x00R\aboolean\x12\x18\n" +
+	"\x06number\x18\x05 \x01(\x01H\x00R\x06number\x12.\n" +
+	"\x05texts\x18\x06 \x01(\v2\x16.weaviate.v1.TextArrayH\x00R\x05texts\x12+\n" +
+	"\x04ints\x18\a \x01(\v2\x15.weaviate.v1.IntArrayH\x00R\x04ints\x127\n" +
+	"\bbooleans\x18\b \x01(\v2\x19.weaviate.v1.BooleanArrayH\x00R\bbooleans\x124\n" +
+	"\anumbers\x18\t \x01(\v2\x18.weaviate.v1.NumberArrayH\x00R\anumbers\x125\n" +
+	"\x03geo\x18\n" +
+	" \x01(\v2!.weaviate.v1.GeoCoordinatesFilterH\x00R\x03geoB\a\n" +
+	"\x05valueB\x10\n" +
+	"\x0e_objects_countB\x0f\n" +
+	"\r_aggregationsB\r\n" +
+	"\v_grouped_by\x1aD\n" +
+	"\aGrouped\x129\n" +
+	"\x06groups\x18\x01 \x03(\v2!.weaviate.v1.AggregateReply.GroupR\x06groupsB\b\n" +
+	"\x06resultBs\n" +
+	"#io.weaviate.client.grpc.protocol.v1B\x16WeaviateProtoAggregateZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v1_aggregate_proto_rawDescOnce sync.Once
+	file_v1_aggregate_proto_rawDescData []byte
+)
+
+func file_v1_aggregate_proto_rawDescGZIP() []byte {
+	file_v1_aggregate_proto_rawDescOnce.Do(func() {
+		file_v1_aggregate_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_aggregate_proto_rawDesc), len(file_v1_aggregate_proto_rawDesc)))
+	})
+	return file_v1_aggregate_proto_rawDescData
+}
+
+var file_v1_aggregate_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
+var file_v1_aggregate_proto_goTypes = []any{
+	(*AggregateRequest)(nil),                                                          // 0: weaviate.v1.AggregateRequest
+	(*AggregateReply)(nil),                                                            // 1: weaviate.v1.AggregateReply
+	(*AggregateRequest_Aggregation)(nil),                                              // 2: weaviate.v1.AggregateRequest.Aggregation
+	(*AggregateRequest_GroupBy)(nil),                                                  // 3: weaviate.v1.AggregateRequest.GroupBy
+	(*AggregateRequest_Aggregation_Integer)(nil),                                      // 4: weaviate.v1.AggregateRequest.Aggregation.Integer
+	(*AggregateRequest_Aggregation_Number)(nil),                                       // 5: weaviate.v1.AggregateRequest.Aggregation.Number
+	(*AggregateRequest_Aggregation_Text)(nil),                                         // 6: weaviate.v1.AggregateRequest.Aggregation.Text
+	(*AggregateRequest_Aggregation_Boolean)(nil),                                      // 7: weaviate.v1.AggregateRequest.Aggregation.Boolean
+	(*AggregateRequest_Aggregation_Date)(nil),                                         // 8: weaviate.v1.AggregateRequest.Aggregation.Date
+	(*AggregateRequest_Aggregation_Reference)(nil),                                    // 9: weaviate.v1.AggregateRequest.Aggregation.Reference
+	(*AggregateReply_Aggregations)(nil),                                               // 10: weaviate.v1.AggregateReply.Aggregations
+	(*AggregateReply_Single)(nil),                                                     // 11: weaviate.v1.AggregateReply.Single
+	(*AggregateReply_Group)(nil),                                                      // 12: weaviate.v1.AggregateReply.Group
+	(*AggregateReply_Grouped)(nil),                                                    // 13: weaviate.v1.AggregateReply.Grouped
+	(*AggregateReply_Aggregations_Aggregation)(nil),                                   // 14: weaviate.v1.AggregateReply.Aggregations.Aggregation
+	(*AggregateReply_Aggregations_Aggregation_Integer)(nil),                           // 15: weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer
+	(*AggregateReply_Aggregations_Aggregation_Number)(nil),                            // 16: weaviate.v1.AggregateReply.Aggregations.Aggregation.Number
+	(*AggregateReply_Aggregations_Aggregation_Text)(nil),                              // 17: weaviate.v1.AggregateReply.Aggregations.Aggregation.Text
+	(*AggregateReply_Aggregations_Aggregation_Boolean)(nil),                           // 18: weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean
+	(*AggregateReply_Aggregations_Aggregation_Date)(nil),                              // 19: weaviate.v1.AggregateReply.Aggregations.Aggregation.Date
+	(*AggregateReply_Aggregations_Aggregation_Reference)(nil),                         // 20: weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference
+	(*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences)(nil),               // 21: weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences
+	(*AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence)(nil), // 22: weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence
+	(*AggregateReply_Group_GroupedBy)(nil),                                            // 23: weaviate.v1.AggregateReply.Group.GroupedBy
+	(*Filters)(nil),                                                                   // 24: weaviate.v1.Filters
+	(*Hybrid)(nil),                                                                    // 25: weaviate.v1.Hybrid
+	(*NearVector)(nil),                                                                // 26: weaviate.v1.NearVector
+	(*NearObject)(nil),                                                                // 27: weaviate.v1.NearObject
+	(*NearTextSearch)(nil),                                                            // 28: weaviate.v1.NearTextSearch
+	(*NearImageSearch)(nil),                                                           // 29: weaviate.v1.NearImageSearch
+	(*NearAudioSearch)(nil),                                                           // 30: weaviate.v1.NearAudioSearch
+	(*NearVideoSearch)(nil),                                                           // 31: weaviate.v1.NearVideoSearch
+	(*NearDepthSearch)(nil),                                                           // 32: weaviate.v1.NearDepthSearch
+	(*NearThermalSearch)(nil),                                                         // 33: weaviate.v1.NearThermalSearch
+	(*NearIMUSearch)(nil),                                                             // 34: weaviate.v1.NearIMUSearch
+	(*TextArray)(nil),                                                                 // 35: weaviate.v1.TextArray
+	(*IntArray)(nil),                                                                  // 36: weaviate.v1.IntArray
+	(*BooleanArray)(nil),                                                              // 37: weaviate.v1.BooleanArray
+	(*NumberArray)(nil),                                                               // 38: weaviate.v1.NumberArray
+	(*GeoCoordinatesFilter)(nil),                                                      // 39: weaviate.v1.GeoCoordinatesFilter
+}
+var file_v1_aggregate_proto_depIdxs = []int32{
+	2,  // 0: weaviate.v1.AggregateRequest.aggregations:type_name -> weaviate.v1.AggregateRequest.Aggregation
+	3,  // 1: weaviate.v1.AggregateRequest.group_by:type_name -> weaviate.v1.AggregateRequest.GroupBy
+	24, // 2: weaviate.v1.AggregateRequest.filters:type_name -> weaviate.v1.Filters
+	25, // 3: weaviate.v1.AggregateRequest.hybrid:type_name -> weaviate.v1.Hybrid
+	26, // 4: weaviate.v1.AggregateRequest.near_vector:type_name -> weaviate.v1.NearVector
+	27, // 5: weaviate.v1.AggregateRequest.near_object:type_name -> weaviate.v1.NearObject
+	28, // 6: weaviate.v1.AggregateRequest.near_text:type_name -> weaviate.v1.NearTextSearch
+	29, // 7: weaviate.v1.AggregateRequest.near_image:type_name -> weaviate.v1.NearImageSearch
+	30, // 8: weaviate.v1.AggregateRequest.near_audio:type_name -> weaviate.v1.NearAudioSearch
+	31, // 9: weaviate.v1.AggregateRequest.near_video:type_name -> weaviate.v1.NearVideoSearch
+	32, // 10: weaviate.v1.AggregateRequest.near_depth:type_name -> weaviate.v1.NearDepthSearch
+	33, // 11: weaviate.v1.AggregateRequest.near_thermal:type_name -> weaviate.v1.NearThermalSearch
+	34, // 12: weaviate.v1.AggregateRequest.near_imu:type_name -> weaviate.v1.NearIMUSearch
+	11, // 13: weaviate.v1.AggregateReply.single_result:type_name -> weaviate.v1.AggregateReply.Single
+	13, // 14: weaviate.v1.AggregateReply.grouped_results:type_name -> weaviate.v1.AggregateReply.Grouped
+	4,  // 15: weaviate.v1.AggregateRequest.Aggregation.int:type_name -> weaviate.v1.AggregateRequest.Aggregation.Integer
+	5,  // 16: weaviate.v1.AggregateRequest.Aggregation.number:type_name -> weaviate.v1.AggregateRequest.Aggregation.Number
+	6,  // 17: weaviate.v1.AggregateRequest.Aggregation.text:type_name -> weaviate.v1.AggregateRequest.Aggregation.Text
+	7,  // 18: weaviate.v1.AggregateRequest.Aggregation.boolean:type_name -> weaviate.v1.AggregateRequest.Aggregation.Boolean
+	8,  // 19: weaviate.v1.AggregateRequest.Aggregation.date:type_name -> weaviate.v1.AggregateRequest.Aggregation.Date
+	9,  // 20: weaviate.v1.AggregateRequest.Aggregation.reference:type_name -> weaviate.v1.AggregateRequest.Aggregation.Reference
+	14, // 21: weaviate.v1.AggregateReply.Aggregations.aggregations:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation
+	10, // 22: weaviate.v1.AggregateReply.Single.aggregations:type_name -> weaviate.v1.AggregateReply.Aggregations
+	10, // 23: weaviate.v1.AggregateReply.Group.aggregations:type_name -> weaviate.v1.AggregateReply.Aggregations
+	23, // 24: weaviate.v1.AggregateReply.Group.grouped_by:type_name -> weaviate.v1.AggregateReply.Group.GroupedBy
+	12, // 25: weaviate.v1.AggregateReply.Grouped.groups:type_name -> weaviate.v1.AggregateReply.Group
+	15, // 26: weaviate.v1.AggregateReply.Aggregations.Aggregation.int:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer
+	16, // 27: weaviate.v1.AggregateReply.Aggregations.Aggregation.number:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Number
+	17, // 28: weaviate.v1.AggregateReply.Aggregations.Aggregation.text:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Text
+	18, // 29: weaviate.v1.AggregateReply.Aggregations.Aggregation.boolean:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean
+	19, // 30: weaviate.v1.AggregateReply.Aggregations.Aggregation.date:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Date
+	20, // 31: weaviate.v1.AggregateReply.Aggregations.Aggregation.reference:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference
+	21, // 32: weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.top_occurences:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences
+	22, // 33: weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.items:type_name -> weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence
+	35, // 34: weaviate.v1.AggregateReply.Group.GroupedBy.texts:type_name -> weaviate.v1.TextArray
+	36, // 35: weaviate.v1.AggregateReply.Group.GroupedBy.ints:type_name -> weaviate.v1.IntArray
+	37, // 36: weaviate.v1.AggregateReply.Group.GroupedBy.booleans:type_name -> weaviate.v1.BooleanArray
+	38, // 37: weaviate.v1.AggregateReply.Group.GroupedBy.numbers:type_name -> weaviate.v1.NumberArray
+	39, // 38: weaviate.v1.AggregateReply.Group.GroupedBy.geo:type_name -> weaviate.v1.GeoCoordinatesFilter
+	39, // [39:39] is the sub-list for method output_type
+	39, // [39:39] is the sub-list for method input_type
+	39, // [39:39] is the sub-list for extension type_name
+	39, // [39:39] is the sub-list for extension extendee
+	0,  // [0:39] is the sub-list for field type_name
+}
+
+func init() { file_v1_aggregate_proto_init() }
+func file_v1_aggregate_proto_init() {
+	if File_v1_aggregate_proto != nil {
+		return
+	}
+	file_v1_base_proto_init()
+	file_v1_base_search_proto_init()
+	file_v1_aggregate_proto_msgTypes[0].OneofWrappers = []any{
+		(*AggregateRequest_Hybrid)(nil),
+		(*AggregateRequest_NearVector)(nil),
+		(*AggregateRequest_NearObject)(nil),
+		(*AggregateRequest_NearText)(nil),
+		(*AggregateRequest_NearImage)(nil),
+		(*AggregateRequest_NearAudio)(nil),
+		(*AggregateRequest_NearVideo)(nil),
+		(*AggregateRequest_NearDepth)(nil),
+		(*AggregateRequest_NearThermal)(nil),
+		(*AggregateRequest_NearImu)(nil),
+	}
+	file_v1_aggregate_proto_msgTypes[1].OneofWrappers = []any{
+		(*AggregateReply_SingleResult)(nil),
+		(*AggregateReply_GroupedResults)(nil),
+	}
+	file_v1_aggregate_proto_msgTypes[2].OneofWrappers = []any{
+		(*AggregateRequest_Aggregation_Int)(nil),
+		(*AggregateRequest_Aggregation_Number_)(nil),
+		(*AggregateRequest_Aggregation_Text_)(nil),
+		(*AggregateRequest_Aggregation_Boolean_)(nil),
+		(*AggregateRequest_Aggregation_Date_)(nil),
+		(*AggregateRequest_Aggregation_Reference_)(nil),
+	}
+	file_v1_aggregate_proto_msgTypes[6].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[11].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[12].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[14].OneofWrappers = []any{
+		(*AggregateReply_Aggregations_Aggregation_Int)(nil),
+		(*AggregateReply_Aggregations_Aggregation_Number_)(nil),
+		(*AggregateReply_Aggregations_Aggregation_Text_)(nil),
+		(*AggregateReply_Aggregations_Aggregation_Boolean_)(nil),
+		(*AggregateReply_Aggregations_Aggregation_Date_)(nil),
+		(*AggregateReply_Aggregations_Aggregation_Reference_)(nil),
+	}
+	file_v1_aggregate_proto_msgTypes[15].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[16].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[17].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[18].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[19].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[20].OneofWrappers = []any{}
+	file_v1_aggregate_proto_msgTypes[23].OneofWrappers = []any{
+		(*AggregateReply_Group_GroupedBy_Text)(nil),
+		(*AggregateReply_Group_GroupedBy_Int)(nil),
+		(*AggregateReply_Group_GroupedBy_Boolean)(nil),
+		(*AggregateReply_Group_GroupedBy_Number)(nil),
+		(*AggregateReply_Group_GroupedBy_Texts)(nil),
+		(*AggregateReply_Group_GroupedBy_Ints)(nil),
+		(*AggregateReply_Group_GroupedBy_Booleans)(nil),
+		(*AggregateReply_Group_GroupedBy_Numbers)(nil),
+		(*AggregateReply_Group_GroupedBy_Geo)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_aggregate_proto_rawDesc), len(file_v1_aggregate_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   24,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v1_aggregate_proto_goTypes,
+		DependencyIndexes: file_v1_aggregate_proto_depIdxs,
+		MessageInfos:      file_v1_aggregate_proto_msgTypes,
+	}.Build()
+	File_v1_aggregate_proto = out.File
+	file_v1_aggregate_proto_goTypes = nil
+	file_v1_aggregate_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/base.pb.go

@@ -0,0 +1,1665 @@
+// 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
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/base_search.pb.go

@@ -0,0 +1,1728 @@
+// 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"
+)
+
+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 CombinationMethod int32
+
+const (
+	CombinationMethod_COMBINATION_METHOD_UNSPECIFIED         CombinationMethod = 0
+	CombinationMethod_COMBINATION_METHOD_TYPE_SUM            CombinationMethod = 1
+	CombinationMethod_COMBINATION_METHOD_TYPE_MIN            CombinationMethod = 2
+	CombinationMethod_COMBINATION_METHOD_TYPE_AVERAGE        CombinationMethod = 3
+	CombinationMethod_COMBINATION_METHOD_TYPE_RELATIVE_SCORE CombinationMethod = 4
+	CombinationMethod_COMBINATION_METHOD_TYPE_MANUAL         CombinationMethod = 5
+)
+
+// Enum value maps for CombinationMethod.
+var (
+	CombinationMethod_name = map[int32]string{
+		0: "COMBINATION_METHOD_UNSPECIFIED",
+		1: "COMBINATION_METHOD_TYPE_SUM",
+		2: "COMBINATION_METHOD_TYPE_MIN",
+		3: "COMBINATION_METHOD_TYPE_AVERAGE",
+		4: "COMBINATION_METHOD_TYPE_RELATIVE_SCORE",
+		5: "COMBINATION_METHOD_TYPE_MANUAL",
+	}
+	CombinationMethod_value = map[string]int32{
+		"COMBINATION_METHOD_UNSPECIFIED":         0,
+		"COMBINATION_METHOD_TYPE_SUM":            1,
+		"COMBINATION_METHOD_TYPE_MIN":            2,
+		"COMBINATION_METHOD_TYPE_AVERAGE":        3,
+		"COMBINATION_METHOD_TYPE_RELATIVE_SCORE": 4,
+		"COMBINATION_METHOD_TYPE_MANUAL":         5,
+	}
+)
+
+func (x CombinationMethod) Enum() *CombinationMethod {
+	p := new(CombinationMethod)
+	*p = x
+	return p
+}
+
+func (x CombinationMethod) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CombinationMethod) Descriptor() protoreflect.EnumDescriptor {
+	return file_v1_base_search_proto_enumTypes[0].Descriptor()
+}
+
+func (CombinationMethod) Type() protoreflect.EnumType {
+	return &file_v1_base_search_proto_enumTypes[0]
+}
+
+func (x CombinationMethod) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use CombinationMethod.Descriptor instead.
+func (CombinationMethod) EnumDescriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{0}
+}
+
+type SearchOperatorOptions_Operator int32
+
+const (
+	SearchOperatorOptions_OPERATOR_UNSPECIFIED SearchOperatorOptions_Operator = 0
+	SearchOperatorOptions_OPERATOR_OR          SearchOperatorOptions_Operator = 1
+	SearchOperatorOptions_OPERATOR_AND         SearchOperatorOptions_Operator = 2
+)
+
+// Enum value maps for SearchOperatorOptions_Operator.
+var (
+	SearchOperatorOptions_Operator_name = map[int32]string{
+		0: "OPERATOR_UNSPECIFIED",
+		1: "OPERATOR_OR",
+		2: "OPERATOR_AND",
+	}
+	SearchOperatorOptions_Operator_value = map[string]int32{
+		"OPERATOR_UNSPECIFIED": 0,
+		"OPERATOR_OR":          1,
+		"OPERATOR_AND":         2,
+	}
+)
+
+func (x SearchOperatorOptions_Operator) Enum() *SearchOperatorOptions_Operator {
+	p := new(SearchOperatorOptions_Operator)
+	*p = x
+	return p
+}
+
+func (x SearchOperatorOptions_Operator) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (SearchOperatorOptions_Operator) Descriptor() protoreflect.EnumDescriptor {
+	return file_v1_base_search_proto_enumTypes[1].Descriptor()
+}
+
+func (SearchOperatorOptions_Operator) Type() protoreflect.EnumType {
+	return &file_v1_base_search_proto_enumTypes[1]
+}
+
+func (x SearchOperatorOptions_Operator) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use SearchOperatorOptions_Operator.Descriptor instead.
+func (SearchOperatorOptions_Operator) EnumDescriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{3, 0}
+}
+
+type Hybrid_FusionType int32
+
+const (
+	Hybrid_FUSION_TYPE_UNSPECIFIED    Hybrid_FusionType = 0
+	Hybrid_FUSION_TYPE_RANKED         Hybrid_FusionType = 1
+	Hybrid_FUSION_TYPE_RELATIVE_SCORE Hybrid_FusionType = 2
+)
+
+// Enum value maps for Hybrid_FusionType.
+var (
+	Hybrid_FusionType_name = map[int32]string{
+		0: "FUSION_TYPE_UNSPECIFIED",
+		1: "FUSION_TYPE_RANKED",
+		2: "FUSION_TYPE_RELATIVE_SCORE",
+	}
+	Hybrid_FusionType_value = map[string]int32{
+		"FUSION_TYPE_UNSPECIFIED":    0,
+		"FUSION_TYPE_RANKED":         1,
+		"FUSION_TYPE_RELATIVE_SCORE": 2,
+	}
+)
+
+func (x Hybrid_FusionType) Enum() *Hybrid_FusionType {
+	p := new(Hybrid_FusionType)
+	*p = x
+	return p
+}
+
+func (x Hybrid_FusionType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Hybrid_FusionType) Descriptor() protoreflect.EnumDescriptor {
+	return file_v1_base_search_proto_enumTypes[2].Descriptor()
+}
+
+func (Hybrid_FusionType) Type() protoreflect.EnumType {
+	return &file_v1_base_search_proto_enumTypes[2]
+}
+
+func (x Hybrid_FusionType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Hybrid_FusionType.Descriptor instead.
+func (Hybrid_FusionType) EnumDescriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{4, 0}
+}
+
+type WeightsForTarget struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Target        string                 `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
+	Weight        float32                `protobuf:"fixed32,2,opt,name=weight,proto3" json:"weight,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *WeightsForTarget) Reset() {
+	*x = WeightsForTarget{}
+	mi := &file_v1_base_search_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *WeightsForTarget) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*WeightsForTarget) ProtoMessage() {}
+
+func (x *WeightsForTarget) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 WeightsForTarget.ProtoReflect.Descriptor instead.
+func (*WeightsForTarget) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *WeightsForTarget) GetTarget() string {
+	if x != nil {
+		return x.Target
+	}
+	return ""
+}
+
+func (x *WeightsForTarget) GetWeight() float32 {
+	if x != nil {
+		return x.Weight
+	}
+	return 0
+}
+
+type Targets struct {
+	state             protoimpl.MessageState `protogen:"open.v1"`
+	TargetVectors     []string               `protobuf:"bytes,1,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"`
+	Combination       CombinationMethod      `protobuf:"varint,2,opt,name=combination,proto3,enum=weaviate.v1.CombinationMethod" json:"combination,omitempty"`
+	WeightsForTargets []*WeightsForTarget    `protobuf:"bytes,4,rep,name=weights_for_targets,json=weightsForTargets,proto3" json:"weights_for_targets,omitempty"`
+	unknownFields     protoimpl.UnknownFields
+	sizeCache         protoimpl.SizeCache
+}
+
+func (x *Targets) Reset() {
+	*x = Targets{}
+	mi := &file_v1_base_search_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Targets) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Targets) ProtoMessage() {}
+
+func (x *Targets) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 Targets.ProtoReflect.Descriptor instead.
+func (*Targets) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Targets) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *Targets) GetCombination() CombinationMethod {
+	if x != nil {
+		return x.Combination
+	}
+	return CombinationMethod_COMBINATION_METHOD_UNSPECIFIED
+}
+
+func (x *Targets) GetWeightsForTargets() []*WeightsForTarget {
+	if x != nil {
+		return x.WeightsForTargets
+	}
+	return nil
+}
+
+type VectorForTarget 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_search.proto.
+	VectorBytes   []byte     `protobuf:"bytes,2,opt,name=vector_bytes,json=vectorBytes,proto3" json:"vector_bytes,omitempty"` // deprecated in 1.29.0 - use vectors
+	Vectors       []*Vectors `protobuf:"bytes,3,rep,name=vectors,proto3" json:"vectors,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *VectorForTarget) Reset() {
+	*x = VectorForTarget{}
+	mi := &file_v1_base_search_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *VectorForTarget) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*VectorForTarget) ProtoMessage() {}
+
+func (x *VectorForTarget) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 VectorForTarget.ProtoReflect.Descriptor instead.
+func (*VectorForTarget) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *VectorForTarget) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *VectorForTarget) GetVectorBytes() []byte {
+	if x != nil {
+		return x.VectorBytes
+	}
+	return nil
+}
+
+func (x *VectorForTarget) GetVectors() []*Vectors {
+	if x != nil {
+		return x.Vectors
+	}
+	return nil
+}
+
+type SearchOperatorOptions struct {
+	state                protoimpl.MessageState         `protogen:"open.v1"`
+	Operator             SearchOperatorOptions_Operator `protobuf:"varint,1,opt,name=operator,proto3,enum=weaviate.v1.SearchOperatorOptions_Operator" json:"operator,omitempty"`
+	MinimumOrTokensMatch *int32                         `protobuf:"varint,2,opt,name=minimum_or_tokens_match,json=minimumOrTokensMatch,proto3,oneof" json:"minimum_or_tokens_match,omitempty"`
+	unknownFields        protoimpl.UnknownFields
+	sizeCache            protoimpl.SizeCache
+}
+
+func (x *SearchOperatorOptions) Reset() {
+	*x = SearchOperatorOptions{}
+	mi := &file_v1_base_search_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *SearchOperatorOptions) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SearchOperatorOptions) ProtoMessage() {}
+
+func (x *SearchOperatorOptions) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 SearchOperatorOptions.ProtoReflect.Descriptor instead.
+func (*SearchOperatorOptions) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *SearchOperatorOptions) GetOperator() SearchOperatorOptions_Operator {
+	if x != nil {
+		return x.Operator
+	}
+	return SearchOperatorOptions_OPERATOR_UNSPECIFIED
+}
+
+func (x *SearchOperatorOptions) GetMinimumOrTokensMatch() int32 {
+	if x != nil && x.MinimumOrTokensMatch != nil {
+		return *x.MinimumOrTokensMatch
+	}
+	return 0
+}
+
+type Hybrid struct {
+	state      protoimpl.MessageState `protogen:"open.v1"`
+	Query      string                 `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
+	Properties []string               `protobuf:"bytes,2,rep,name=properties,proto3" json:"properties,omitempty"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	//
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	Vector     []float32         `protobuf:"fixed32,3,rep,packed,name=vector,proto3" json:"vector,omitempty"` // will be removed in the future, use vectors
+	Alpha      float32           `protobuf:"fixed32,4,opt,name=alpha,proto3" json:"alpha,omitempty"`
+	FusionType Hybrid_FusionType `protobuf:"varint,5,opt,name=fusion_type,json=fusionType,proto3,enum=weaviate.v1.Hybrid_FusionType" json:"fusion_type,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	VectorBytes []byte `protobuf:"bytes,6,opt,name=vector_bytes,json=vectorBytes,proto3" json:"vector_bytes,omitempty"` // deprecated in 1.29.0 - use vectors
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors      []string               `protobuf:"bytes,7,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	NearText           *NearTextSearch        `protobuf:"bytes,8,opt,name=near_text,json=nearText,proto3" json:"near_text,omitempty"`                // targets in msg is ignored and should not be set for hybrid
+	NearVector         *NearVector            `protobuf:"bytes,9,opt,name=near_vector,json=nearVector,proto3" json:"near_vector,omitempty"`          // same as above. Use the target vector in the hybrid message
+	Targets            *Targets               `protobuf:"bytes,10,opt,name=targets,proto3" json:"targets,omitempty"`
+	Bm25SearchOperator *SearchOperatorOptions `protobuf:"bytes,11,opt,name=bm25_search_operator,json=bm25SearchOperator,proto3,oneof" json:"bm25_search_operator,omitempty"`
+	// only vector distance, but keep it extendable
+	//
+	// Types that are valid to be assigned to Threshold:
+	//
+	//	*Hybrid_VectorDistance
+	Threshold     isHybrid_Threshold `protobuf_oneof:"threshold"`
+	Vectors       []*Vectors         `protobuf:"bytes,21,rep,name=vectors,proto3" json:"vectors,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Hybrid) Reset() {
+	*x = Hybrid{}
+	mi := &file_v1_base_search_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Hybrid) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Hybrid) ProtoMessage() {}
+
+func (x *Hybrid) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 Hybrid.ProtoReflect.Descriptor instead.
+func (*Hybrid) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Hybrid) GetQuery() string {
+	if x != nil {
+		return x.Query
+	}
+	return ""
+}
+
+func (x *Hybrid) GetProperties() []string {
+	if x != nil {
+		return x.Properties
+	}
+	return nil
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *Hybrid) GetVector() []float32 {
+	if x != nil {
+		return x.Vector
+	}
+	return nil
+}
+
+func (x *Hybrid) GetAlpha() float32 {
+	if x != nil {
+		return x.Alpha
+	}
+	return 0
+}
+
+func (x *Hybrid) GetFusionType() Hybrid_FusionType {
+	if x != nil {
+		return x.FusionType
+	}
+	return Hybrid_FUSION_TYPE_UNSPECIFIED
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *Hybrid) GetVectorBytes() []byte {
+	if x != nil {
+		return x.VectorBytes
+	}
+	return nil
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *Hybrid) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *Hybrid) GetNearText() *NearTextSearch {
+	if x != nil {
+		return x.NearText
+	}
+	return nil
+}
+
+func (x *Hybrid) GetNearVector() *NearVector {
+	if x != nil {
+		return x.NearVector
+	}
+	return nil
+}
+
+func (x *Hybrid) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+func (x *Hybrid) GetBm25SearchOperator() *SearchOperatorOptions {
+	if x != nil {
+		return x.Bm25SearchOperator
+	}
+	return nil
+}
+
+func (x *Hybrid) GetThreshold() isHybrid_Threshold {
+	if x != nil {
+		return x.Threshold
+	}
+	return nil
+}
+
+func (x *Hybrid) GetVectorDistance() float32 {
+	if x != nil {
+		if x, ok := x.Threshold.(*Hybrid_VectorDistance); ok {
+			return x.VectorDistance
+		}
+	}
+	return 0
+}
+
+func (x *Hybrid) GetVectors() []*Vectors {
+	if x != nil {
+		return x.Vectors
+	}
+	return nil
+}
+
+type isHybrid_Threshold interface {
+	isHybrid_Threshold()
+}
+
+type Hybrid_VectorDistance struct {
+	VectorDistance float32 `protobuf:"fixed32,20,opt,name=vector_distance,json=vectorDistance,proto3,oneof"`
+}
+
+func (*Hybrid_VectorDistance) isHybrid_Threshold() {}
+
+type NearVector struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	//
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	Vector    []float32 `protobuf:"fixed32,1,rep,packed,name=vector,proto3" json:"vector,omitempty"` // will be removed in the future, use vectors
+	Certainty *float64  `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64  `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	VectorBytes []byte `protobuf:"bytes,4,opt,name=vector_bytes,json=vectorBytes,proto3" json:"vector_bytes,omitempty"` // deprecated in 1.29.0 - use vectors
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,5,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,6,opt,name=targets,proto3" json:"targets,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	VectorPerTarget  map[string][]byte  `protobuf:"bytes,7,rep,name=vector_per_target,json=vectorPerTarget,proto3" json:"vector_per_target,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // deprecated in 1.26.2 - use vector_for_targets
+	VectorForTargets []*VectorForTarget `protobuf:"bytes,8,rep,name=vector_for_targets,json=vectorForTargets,proto3" json:"vector_for_targets,omitempty"`
+	Vectors          []*Vectors         `protobuf:"bytes,9,rep,name=vectors,proto3" json:"vectors,omitempty"`
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *NearVector) Reset() {
+	*x = NearVector{}
+	mi := &file_v1_base_search_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearVector) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearVector) ProtoMessage() {}
+
+func (x *NearVector) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearVector.ProtoReflect.Descriptor instead.
+func (*NearVector) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{5}
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearVector) GetVector() []float32 {
+	if x != nil {
+		return x.Vector
+	}
+	return nil
+}
+
+func (x *NearVector) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearVector) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearVector) GetVectorBytes() []byte {
+	if x != nil {
+		return x.VectorBytes
+	}
+	return nil
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearVector) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearVector) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearVector) GetVectorPerTarget() map[string][]byte {
+	if x != nil {
+		return x.VectorPerTarget
+	}
+	return nil
+}
+
+func (x *NearVector) GetVectorForTargets() []*VectorForTarget {
+	if x != nil {
+		return x.VectorForTargets
+	}
+	return nil
+}
+
+func (x *NearVector) GetVectors() []*Vectors {
+	if x != nil {
+		return x.Vectors
+	}
+	return nil
+}
+
+type NearObject struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Id        string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearObject) Reset() {
+	*x = NearObject{}
+	mi := &file_v1_base_search_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearObject) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearObject) ProtoMessage() {}
+
+func (x *NearObject) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearObject.ProtoReflect.Descriptor instead.
+func (*NearObject) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *NearObject) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+func (x *NearObject) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearObject) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearObject) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearObject) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearTextSearch struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	Query     []string             `protobuf:"bytes,1,rep,name=query,proto3" json:"query,omitempty"`
+	Certainty *float64             `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64             `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	MoveTo    *NearTextSearch_Move `protobuf:"bytes,4,opt,name=move_to,json=moveTo,proto3,oneof" json:"move_to,omitempty"`
+	MoveAway  *NearTextSearch_Move `protobuf:"bytes,5,opt,name=move_away,json=moveAway,proto3,oneof" json:"move_away,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,6,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,7,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearTextSearch) Reset() {
+	*x = NearTextSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearTextSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearTextSearch) ProtoMessage() {}
+
+func (x *NearTextSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearTextSearch.ProtoReflect.Descriptor instead.
+func (*NearTextSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *NearTextSearch) GetQuery() []string {
+	if x != nil {
+		return x.Query
+	}
+	return nil
+}
+
+func (x *NearTextSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearTextSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+func (x *NearTextSearch) GetMoveTo() *NearTextSearch_Move {
+	if x != nil {
+		return x.MoveTo
+	}
+	return nil
+}
+
+func (x *NearTextSearch) GetMoveAway() *NearTextSearch_Move {
+	if x != nil {
+		return x.MoveAway
+	}
+	return nil
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearTextSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearTextSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearImageSearch struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Image     string                 `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearImageSearch) Reset() {
+	*x = NearImageSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearImageSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearImageSearch) ProtoMessage() {}
+
+func (x *NearImageSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearImageSearch.ProtoReflect.Descriptor instead.
+func (*NearImageSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *NearImageSearch) GetImage() string {
+	if x != nil {
+		return x.Image
+	}
+	return ""
+}
+
+func (x *NearImageSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearImageSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearImageSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearImageSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearAudioSearch struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Audio     string                 `protobuf:"bytes,1,opt,name=audio,proto3" json:"audio,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearAudioSearch) Reset() {
+	*x = NearAudioSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearAudioSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearAudioSearch) ProtoMessage() {}
+
+func (x *NearAudioSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearAudioSearch.ProtoReflect.Descriptor instead.
+func (*NearAudioSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *NearAudioSearch) GetAudio() string {
+	if x != nil {
+		return x.Audio
+	}
+	return ""
+}
+
+func (x *NearAudioSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearAudioSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearAudioSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearAudioSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearVideoSearch struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Video     string                 `protobuf:"bytes,1,opt,name=video,proto3" json:"video,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearVideoSearch) Reset() {
+	*x = NearVideoSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearVideoSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearVideoSearch) ProtoMessage() {}
+
+func (x *NearVideoSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearVideoSearch.ProtoReflect.Descriptor instead.
+func (*NearVideoSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *NearVideoSearch) GetVideo() string {
+	if x != nil {
+		return x.Video
+	}
+	return ""
+}
+
+func (x *NearVideoSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearVideoSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearVideoSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearVideoSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearDepthSearch struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Depth     string                 `protobuf:"bytes,1,opt,name=depth,proto3" json:"depth,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearDepthSearch) Reset() {
+	*x = NearDepthSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[11]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearDepthSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearDepthSearch) ProtoMessage() {}
+
+func (x *NearDepthSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearDepthSearch.ProtoReflect.Descriptor instead.
+func (*NearDepthSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *NearDepthSearch) GetDepth() string {
+	if x != nil {
+		return x.Depth
+	}
+	return ""
+}
+
+func (x *NearDepthSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearDepthSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearDepthSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearDepthSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearThermalSearch struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Thermal   string                 `protobuf:"bytes,1,opt,name=thermal,proto3" json:"thermal,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearThermalSearch) Reset() {
+	*x = NearThermalSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[12]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearThermalSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearThermalSearch) ProtoMessage() {}
+
+func (x *NearThermalSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearThermalSearch.ProtoReflect.Descriptor instead.
+func (*NearThermalSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *NearThermalSearch) GetThermal() string {
+	if x != nil {
+		return x.Thermal
+	}
+	return ""
+}
+
+func (x *NearThermalSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearThermalSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearThermalSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearThermalSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type NearIMUSearch struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Imu       string                 `protobuf:"bytes,1,opt,name=imu,proto3" json:"imu,omitempty"`
+	Certainty *float64               `protobuf:"fixed64,2,opt,name=certainty,proto3,oneof" json:"certainty,omitempty"`
+	Distance  *float64               `protobuf:"fixed64,3,opt,name=distance,proto3,oneof" json:"distance,omitempty"`
+	// Deprecated: Marked as deprecated in v1/base_search.proto.
+	TargetVectors []string `protobuf:"bytes,4,rep,name=target_vectors,json=targetVectors,proto3" json:"target_vectors,omitempty"` // deprecated in 1.26 - use targets
+	Targets       *Targets `protobuf:"bytes,5,opt,name=targets,proto3" json:"targets,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearIMUSearch) Reset() {
+	*x = NearIMUSearch{}
+	mi := &file_v1_base_search_proto_msgTypes[13]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearIMUSearch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearIMUSearch) ProtoMessage() {}
+
+func (x *NearIMUSearch) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearIMUSearch.ProtoReflect.Descriptor instead.
+func (*NearIMUSearch) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *NearIMUSearch) GetImu() string {
+	if x != nil {
+		return x.Imu
+	}
+	return ""
+}
+
+func (x *NearIMUSearch) GetCertainty() float64 {
+	if x != nil && x.Certainty != nil {
+		return *x.Certainty
+	}
+	return 0
+}
+
+func (x *NearIMUSearch) GetDistance() float64 {
+	if x != nil && x.Distance != nil {
+		return *x.Distance
+	}
+	return 0
+}
+
+// Deprecated: Marked as deprecated in v1/base_search.proto.
+func (x *NearIMUSearch) GetTargetVectors() []string {
+	if x != nil {
+		return x.TargetVectors
+	}
+	return nil
+}
+
+func (x *NearIMUSearch) GetTargets() *Targets {
+	if x != nil {
+		return x.Targets
+	}
+	return nil
+}
+
+type BM25 struct {
+	state          protoimpl.MessageState `protogen:"open.v1"`
+	Query          string                 `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
+	Properties     []string               `protobuf:"bytes,2,rep,name=properties,proto3" json:"properties,omitempty"`
+	SearchOperator *SearchOperatorOptions `protobuf:"bytes,3,opt,name=search_operator,json=searchOperator,proto3,oneof" json:"search_operator,omitempty"`
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
+}
+
+func (x *BM25) Reset() {
+	*x = BM25{}
+	mi := &file_v1_base_search_proto_msgTypes[14]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BM25) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BM25) ProtoMessage() {}
+
+func (x *BM25) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 BM25.ProtoReflect.Descriptor instead.
+func (*BM25) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *BM25) GetQuery() string {
+	if x != nil {
+		return x.Query
+	}
+	return ""
+}
+
+func (x *BM25) GetProperties() []string {
+	if x != nil {
+		return x.Properties
+	}
+	return nil
+}
+
+func (x *BM25) GetSearchOperator() *SearchOperatorOptions {
+	if x != nil {
+		return x.SearchOperator
+	}
+	return nil
+}
+
+type NearTextSearch_Move struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Force         float32                `protobuf:"fixed32,1,opt,name=force,proto3" json:"force,omitempty"`
+	Concepts      []string               `protobuf:"bytes,2,rep,name=concepts,proto3" json:"concepts,omitempty"`
+	Uuids         []string               `protobuf:"bytes,3,rep,name=uuids,proto3" json:"uuids,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NearTextSearch_Move) Reset() {
+	*x = NearTextSearch_Move{}
+	mi := &file_v1_base_search_proto_msgTypes[16]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NearTextSearch_Move) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NearTextSearch_Move) ProtoMessage() {}
+
+func (x *NearTextSearch_Move) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_base_search_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 NearTextSearch_Move.ProtoReflect.Descriptor instead.
+func (*NearTextSearch_Move) Descriptor() ([]byte, []int) {
+	return file_v1_base_search_proto_rawDescGZIP(), []int{7, 0}
+}
+
+func (x *NearTextSearch_Move) GetForce() float32 {
+	if x != nil {
+		return x.Force
+	}
+	return 0
+}
+
+func (x *NearTextSearch_Move) GetConcepts() []string {
+	if x != nil {
+		return x.Concepts
+	}
+	return nil
+}
+
+func (x *NearTextSearch_Move) GetUuids() []string {
+	if x != nil {
+		return x.Uuids
+	}
+	return nil
+}
+
+var File_v1_base_search_proto protoreflect.FileDescriptor
+
+const file_v1_base_search_proto_rawDesc = "" +
+	"\n" +
+	"\x14v1/base_search.proto\x12\vweaviate.v1\x1a\rv1/base.proto\"B\n" +
+	"\x10WeightsForTarget\x12\x16\n" +
+	"\x06target\x18\x01 \x01(\tR\x06target\x12\x16\n" +
+	"\x06weight\x18\x02 \x01(\x02R\x06weight\"\xc7\x01\n" +
+	"\aTargets\x12%\n" +
+	"\x0etarget_vectors\x18\x01 \x03(\tR\rtargetVectors\x12@\n" +
+	"\vcombination\x18\x02 \x01(\x0e2\x1e.weaviate.v1.CombinationMethodR\vcombination\x12M\n" +
+	"\x13weights_for_targets\x18\x04 \x03(\v2\x1d.weaviate.v1.WeightsForTargetR\x11weightsForTargetsJ\x04\b\x03\x10\x04\"|\n" +
+	"\x0fVectorForTarget\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12%\n" +
+	"\fvector_bytes\x18\x02 \x01(\fB\x02\x18\x01R\vvectorBytes\x12.\n" +
+	"\avectors\x18\x03 \x03(\v2\x14.weaviate.v1.VectorsR\avectors\"\x81\x02\n" +
+	"\x15SearchOperatorOptions\x12G\n" +
+	"\boperator\x18\x01 \x01(\x0e2+.weaviate.v1.SearchOperatorOptions.OperatorR\boperator\x12:\n" +
+	"\x17minimum_or_tokens_match\x18\x02 \x01(\x05H\x00R\x14minimumOrTokensMatch\x88\x01\x01\"G\n" +
+	"\bOperator\x12\x18\n" +
+	"\x14OPERATOR_UNSPECIFIED\x10\x00\x12\x0f\n" +
+	"\vOPERATOR_OR\x10\x01\x12\x10\n" +
+	"\fOPERATOR_AND\x10\x02B\x1a\n" +
+	"\x18_minimum_or_tokens_match\"\xe6\x05\n" +
+	"\x06Hybrid\x12\x14\n" +
+	"\x05query\x18\x01 \x01(\tR\x05query\x12\x1e\n" +
+	"\n" +
+	"properties\x18\x02 \x03(\tR\n" +
+	"properties\x12\x1a\n" +
+	"\x06vector\x18\x03 \x03(\x02B\x02\x18\x01R\x06vector\x12\x14\n" +
+	"\x05alpha\x18\x04 \x01(\x02R\x05alpha\x12?\n" +
+	"\vfusion_type\x18\x05 \x01(\x0e2\x1e.weaviate.v1.Hybrid.FusionTypeR\n" +
+	"fusionType\x12%\n" +
+	"\fvector_bytes\x18\x06 \x01(\fB\x02\x18\x01R\vvectorBytes\x12)\n" +
+	"\x0etarget_vectors\x18\a \x03(\tB\x02\x18\x01R\rtargetVectors\x128\n" +
+	"\tnear_text\x18\b \x01(\v2\x1b.weaviate.v1.NearTextSearchR\bnearText\x128\n" +
+	"\vnear_vector\x18\t \x01(\v2\x17.weaviate.v1.NearVectorR\n" +
+	"nearVector\x12.\n" +
+	"\atargets\x18\n" +
+	" \x01(\v2\x14.weaviate.v1.TargetsR\atargets\x12Y\n" +
+	"\x14bm25_search_operator\x18\v \x01(\v2\".weaviate.v1.SearchOperatorOptionsH\x01R\x12bm25SearchOperator\x88\x01\x01\x12)\n" +
+	"\x0fvector_distance\x18\x14 \x01(\x02H\x00R\x0evectorDistance\x12.\n" +
+	"\avectors\x18\x15 \x03(\v2\x14.weaviate.v1.VectorsR\avectors\"a\n" +
+	"\n" +
+	"FusionType\x12\x1b\n" +
+	"\x17FUSION_TYPE_UNSPECIFIED\x10\x00\x12\x16\n" +
+	"\x12FUSION_TYPE_RANKED\x10\x01\x12\x1e\n" +
+	"\x1aFUSION_TYPE_RELATIVE_SCORE\x10\x02B\v\n" +
+	"\tthresholdB\x17\n" +
+	"\x15_bm25_search_operator\"\xa7\x04\n" +
+	"\n" +
+	"NearVector\x12\x1a\n" +
+	"\x06vector\x18\x01 \x03(\x02B\x02\x18\x01R\x06vector\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12%\n" +
+	"\fvector_bytes\x18\x04 \x01(\fB\x02\x18\x01R\vvectorBytes\x12)\n" +
+	"\x0etarget_vectors\x18\x05 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x06 \x01(\v2\x14.weaviate.v1.TargetsR\atargets\x12\\\n" +
+	"\x11vector_per_target\x18\a \x03(\v2,.weaviate.v1.NearVector.VectorPerTargetEntryB\x02\x18\x01R\x0fvectorPerTarget\x12J\n" +
+	"\x12vector_for_targets\x18\b \x03(\v2\x1c.weaviate.v1.VectorForTargetR\x10vectorForTargets\x12.\n" +
+	"\avectors\x18\t \x03(\v2\x14.weaviate.v1.VectorsR\avectors\x1aB\n" +
+	"\x14VectorPerTargetEntry\x12\x10\n" +
+	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
+	"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01B\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xd6\x01\n" +
+	"\n" +
+	"NearObject\x12\x0e\n" +
+	"\x02id\x18\x01 \x01(\tR\x02id\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xce\x03\n" +
+	"\x0eNearTextSearch\x12\x14\n" +
+	"\x05query\x18\x01 \x03(\tR\x05query\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12>\n" +
+	"\amove_to\x18\x04 \x01(\v2 .weaviate.v1.NearTextSearch.MoveH\x02R\x06moveTo\x88\x01\x01\x12B\n" +
+	"\tmove_away\x18\x05 \x01(\v2 .weaviate.v1.NearTextSearch.MoveH\x03R\bmoveAway\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x06 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\a \x01(\v2\x14.weaviate.v1.TargetsR\atargets\x1aN\n" +
+	"\x04Move\x12\x14\n" +
+	"\x05force\x18\x01 \x01(\x02R\x05force\x12\x1a\n" +
+	"\bconcepts\x18\x02 \x03(\tR\bconcepts\x12\x14\n" +
+	"\x05uuids\x18\x03 \x03(\tR\x05uuidsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distanceB\n" +
+	"\n" +
+	"\b_move_toB\f\n" +
+	"\n" +
+	"_move_away\"\xe1\x01\n" +
+	"\x0fNearImageSearch\x12\x14\n" +
+	"\x05image\x18\x01 \x01(\tR\x05image\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xe1\x01\n" +
+	"\x0fNearAudioSearch\x12\x14\n" +
+	"\x05audio\x18\x01 \x01(\tR\x05audio\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xe1\x01\n" +
+	"\x0fNearVideoSearch\x12\x14\n" +
+	"\x05video\x18\x01 \x01(\tR\x05video\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xe1\x01\n" +
+	"\x0fNearDepthSearch\x12\x14\n" +
+	"\x05depth\x18\x01 \x01(\tR\x05depth\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xe7\x01\n" +
+	"\x11NearThermalSearch\x12\x18\n" +
+	"\athermal\x18\x01 \x01(\tR\athermal\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xdb\x01\n" +
+	"\rNearIMUSearch\x12\x10\n" +
+	"\x03imu\x18\x01 \x01(\tR\x03imu\x12!\n" +
+	"\tcertainty\x18\x02 \x01(\x01H\x00R\tcertainty\x88\x01\x01\x12\x1f\n" +
+	"\bdistance\x18\x03 \x01(\x01H\x01R\bdistance\x88\x01\x01\x12)\n" +
+	"\x0etarget_vectors\x18\x04 \x03(\tB\x02\x18\x01R\rtargetVectors\x12.\n" +
+	"\atargets\x18\x05 \x01(\v2\x14.weaviate.v1.TargetsR\atargetsB\f\n" +
+	"\n" +
+	"_certaintyB\v\n" +
+	"\t_distance\"\xa2\x01\n" +
+	"\x04BM25\x12\x14\n" +
+	"\x05query\x18\x01 \x01(\tR\x05query\x12\x1e\n" +
+	"\n" +
+	"properties\x18\x02 \x03(\tR\n" +
+	"properties\x12P\n" +
+	"\x0fsearch_operator\x18\x03 \x01(\v2\".weaviate.v1.SearchOperatorOptionsH\x00R\x0esearchOperator\x88\x01\x01B\x12\n" +
+	"\x10_search_operator*\xee\x01\n" +
+	"\x11CombinationMethod\x12\"\n" +
+	"\x1eCOMBINATION_METHOD_UNSPECIFIED\x10\x00\x12\x1f\n" +
+	"\x1bCOMBINATION_METHOD_TYPE_SUM\x10\x01\x12\x1f\n" +
+	"\x1bCOMBINATION_METHOD_TYPE_MIN\x10\x02\x12#\n" +
+	"\x1fCOMBINATION_METHOD_TYPE_AVERAGE\x10\x03\x12*\n" +
+	"&COMBINATION_METHOD_TYPE_RELATIVE_SCORE\x10\x04\x12\"\n" +
+	"\x1eCOMBINATION_METHOD_TYPE_MANUAL\x10\x05Bt\n" +
+	"#io.weaviate.client.grpc.protocol.v1B\x17WeaviateProtoBaseSearchZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v1_base_search_proto_rawDescOnce sync.Once
+	file_v1_base_search_proto_rawDescData []byte
+)
+
+func file_v1_base_search_proto_rawDescGZIP() []byte {
+	file_v1_base_search_proto_rawDescOnce.Do(func() {
+		file_v1_base_search_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_base_search_proto_rawDesc), len(file_v1_base_search_proto_rawDesc)))
+	})
+	return file_v1_base_search_proto_rawDescData
+}
+
+var file_v1_base_search_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_v1_base_search_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
+var file_v1_base_search_proto_goTypes = []any{
+	(CombinationMethod)(0),              // 0: weaviate.v1.CombinationMethod
+	(SearchOperatorOptions_Operator)(0), // 1: weaviate.v1.SearchOperatorOptions.Operator
+	(Hybrid_FusionType)(0),              // 2: weaviate.v1.Hybrid.FusionType
+	(*WeightsForTarget)(nil),            // 3: weaviate.v1.WeightsForTarget
+	(*Targets)(nil),                     // 4: weaviate.v1.Targets
+	(*VectorForTarget)(nil),             // 5: weaviate.v1.VectorForTarget
+	(*SearchOperatorOptions)(nil),       // 6: weaviate.v1.SearchOperatorOptions
+	(*Hybrid)(nil),                      // 7: weaviate.v1.Hybrid
+	(*NearVector)(nil),                  // 8: weaviate.v1.NearVector
+	(*NearObject)(nil),                  // 9: weaviate.v1.NearObject
+	(*NearTextSearch)(nil),              // 10: weaviate.v1.NearTextSearch
+	(*NearImageSearch)(nil),             // 11: weaviate.v1.NearImageSearch
+	(*NearAudioSearch)(nil),             // 12: weaviate.v1.NearAudioSearch
+	(*NearVideoSearch)(nil),             // 13: weaviate.v1.NearVideoSearch
+	(*NearDepthSearch)(nil),             // 14: weaviate.v1.NearDepthSearch
+	(*NearThermalSearch)(nil),           // 15: weaviate.v1.NearThermalSearch
+	(*NearIMUSearch)(nil),               // 16: weaviate.v1.NearIMUSearch
+	(*BM25)(nil),                        // 17: weaviate.v1.BM25
+	nil,                                 // 18: weaviate.v1.NearVector.VectorPerTargetEntry
+	(*NearTextSearch_Move)(nil),         // 19: weaviate.v1.NearTextSearch.Move
+	(*Vectors)(nil),                     // 20: weaviate.v1.Vectors
+}
+var file_v1_base_search_proto_depIdxs = []int32{
+	0,  // 0: weaviate.v1.Targets.combination:type_name -> weaviate.v1.CombinationMethod
+	3,  // 1: weaviate.v1.Targets.weights_for_targets:type_name -> weaviate.v1.WeightsForTarget
+	20, // 2: weaviate.v1.VectorForTarget.vectors:type_name -> weaviate.v1.Vectors
+	1,  // 3: weaviate.v1.SearchOperatorOptions.operator:type_name -> weaviate.v1.SearchOperatorOptions.Operator
+	2,  // 4: weaviate.v1.Hybrid.fusion_type:type_name -> weaviate.v1.Hybrid.FusionType
+	10, // 5: weaviate.v1.Hybrid.near_text:type_name -> weaviate.v1.NearTextSearch
+	8,  // 6: weaviate.v1.Hybrid.near_vector:type_name -> weaviate.v1.NearVector
+	4,  // 7: weaviate.v1.Hybrid.targets:type_name -> weaviate.v1.Targets
+	6,  // 8: weaviate.v1.Hybrid.bm25_search_operator:type_name -> weaviate.v1.SearchOperatorOptions
+	20, // 9: weaviate.v1.Hybrid.vectors:type_name -> weaviate.v1.Vectors
+	4,  // 10: weaviate.v1.NearVector.targets:type_name -> weaviate.v1.Targets
+	18, // 11: weaviate.v1.NearVector.vector_per_target:type_name -> weaviate.v1.NearVector.VectorPerTargetEntry
+	5,  // 12: weaviate.v1.NearVector.vector_for_targets:type_name -> weaviate.v1.VectorForTarget
+	20, // 13: weaviate.v1.NearVector.vectors:type_name -> weaviate.v1.Vectors
+	4,  // 14: weaviate.v1.NearObject.targets:type_name -> weaviate.v1.Targets
+	19, // 15: weaviate.v1.NearTextSearch.move_to:type_name -> weaviate.v1.NearTextSearch.Move
+	19, // 16: weaviate.v1.NearTextSearch.move_away:type_name -> weaviate.v1.NearTextSearch.Move
+	4,  // 17: weaviate.v1.NearTextSearch.targets:type_name -> weaviate.v1.Targets
+	4,  // 18: weaviate.v1.NearImageSearch.targets:type_name -> weaviate.v1.Targets
+	4,  // 19: weaviate.v1.NearAudioSearch.targets:type_name -> weaviate.v1.Targets
+	4,  // 20: weaviate.v1.NearVideoSearch.targets:type_name -> weaviate.v1.Targets
+	4,  // 21: weaviate.v1.NearDepthSearch.targets:type_name -> weaviate.v1.Targets
+	4,  // 22: weaviate.v1.NearThermalSearch.targets:type_name -> weaviate.v1.Targets
+	4,  // 23: weaviate.v1.NearIMUSearch.targets:type_name -> weaviate.v1.Targets
+	6,  // 24: weaviate.v1.BM25.search_operator:type_name -> weaviate.v1.SearchOperatorOptions
+	25, // [25:25] is the sub-list for method output_type
+	25, // [25:25] is the sub-list for method input_type
+	25, // [25:25] is the sub-list for extension type_name
+	25, // [25:25] is the sub-list for extension extendee
+	0,  // [0:25] is the sub-list for field type_name
+}
+
+func init() { file_v1_base_search_proto_init() }
+func file_v1_base_search_proto_init() {
+	if File_v1_base_search_proto != nil {
+		return
+	}
+	file_v1_base_proto_init()
+	file_v1_base_search_proto_msgTypes[3].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[4].OneofWrappers = []any{
+		(*Hybrid_VectorDistance)(nil),
+	}
+	file_v1_base_search_proto_msgTypes[5].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[6].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[7].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[8].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[9].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[10].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[11].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[12].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[13].OneofWrappers = []any{}
+	file_v1_base_search_proto_msgTypes[14].OneofWrappers = []any{}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_base_search_proto_rawDesc), len(file_v1_base_search_proto_rawDesc)),
+			NumEnums:      3,
+			NumMessages:   17,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v1_base_search_proto_goTypes,
+		DependencyIndexes: file_v1_base_search_proto_depIdxs,
+		EnumInfos:         file_v1_base_search_proto_enumTypes,
+		MessageInfos:      file_v1_base_search_proto_msgTypes,
+	}.Build()
+	File_v1_base_search_proto = out.File
+	file_v1_base_search_proto_goTypes = nil
+	file_v1_base_search_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/batch.pb.go

@@ -0,0 +1,1682 @@
+// 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 BatchObjectsRequest struct {
+	state            protoimpl.MessageState `protogen:"open.v1"`
+	Objects          []*BatchObject         `protobuf:"bytes,1,rep,name=objects,proto3" json:"objects,omitempty"`
+	ConsistencyLevel *ConsistencyLevel      `protobuf:"varint,2,opt,name=consistency_level,json=consistencyLevel,proto3,enum=weaviate.v1.ConsistencyLevel,oneof" json:"consistency_level,omitempty"`
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *BatchObjectsRequest) Reset() {
+	*x = BatchObjectsRequest{}
+	mi := &file_v1_batch_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObjectsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObjectsRequest) ProtoMessage() {}
+
+func (x *BatchObjectsRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObjectsRequest.ProtoReflect.Descriptor instead.
+func (*BatchObjectsRequest) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *BatchObjectsRequest) GetObjects() []*BatchObject {
+	if x != nil {
+		return x.Objects
+	}
+	return nil
+}
+
+func (x *BatchObjectsRequest) GetConsistencyLevel() ConsistencyLevel {
+	if x != nil && x.ConsistencyLevel != nil {
+		return *x.ConsistencyLevel
+	}
+	return ConsistencyLevel_CONSISTENCY_LEVEL_UNSPECIFIED
+}
+
+type BatchReferencesRequest struct {
+	state            protoimpl.MessageState `protogen:"open.v1"`
+	References       []*BatchReference      `protobuf:"bytes,1,rep,name=references,proto3" json:"references,omitempty"`
+	ConsistencyLevel *ConsistencyLevel      `protobuf:"varint,2,opt,name=consistency_level,json=consistencyLevel,proto3,enum=weaviate.v1.ConsistencyLevel,oneof" json:"consistency_level,omitempty"`
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *BatchReferencesRequest) Reset() {
+	*x = BatchReferencesRequest{}
+	mi := &file_v1_batch_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchReferencesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchReferencesRequest) ProtoMessage() {}
+
+func (x *BatchReferencesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchReferencesRequest.ProtoReflect.Descriptor instead.
+func (*BatchReferencesRequest) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *BatchReferencesRequest) GetReferences() []*BatchReference {
+	if x != nil {
+		return x.References
+	}
+	return nil
+}
+
+func (x *BatchReferencesRequest) GetConsistencyLevel() ConsistencyLevel {
+	if x != nil && x.ConsistencyLevel != nil {
+		return *x.ConsistencyLevel
+	}
+	return ConsistencyLevel_CONSISTENCY_LEVEL_UNSPECIFIED
+}
+
+type BatchSendRequest struct {
+	state    protoimpl.MessageState `protogen:"open.v1"`
+	StreamId string                 `protobuf:"bytes,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"`
+	// Types that are valid to be assigned to Message:
+	//
+	//	*BatchSendRequest_Objects_
+	//	*BatchSendRequest_References_
+	//	*BatchSendRequest_Stop_
+	Message       isBatchSendRequest_Message `protobuf_oneof:"message"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchSendRequest) Reset() {
+	*x = BatchSendRequest{}
+	mi := &file_v1_batch_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchSendRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchSendRequest) ProtoMessage() {}
+
+func (x *BatchSendRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchSendRequest.ProtoReflect.Descriptor instead.
+func (*BatchSendRequest) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *BatchSendRequest) GetStreamId() string {
+	if x != nil {
+		return x.StreamId
+	}
+	return ""
+}
+
+func (x *BatchSendRequest) GetMessage() isBatchSendRequest_Message {
+	if x != nil {
+		return x.Message
+	}
+	return nil
+}
+
+func (x *BatchSendRequest) GetObjects() *BatchSendRequest_Objects {
+	if x != nil {
+		if x, ok := x.Message.(*BatchSendRequest_Objects_); ok {
+			return x.Objects
+		}
+	}
+	return nil
+}
+
+func (x *BatchSendRequest) GetReferences() *BatchSendRequest_References {
+	if x != nil {
+		if x, ok := x.Message.(*BatchSendRequest_References_); ok {
+			return x.References
+		}
+	}
+	return nil
+}
+
+func (x *BatchSendRequest) GetStop() *BatchSendRequest_Stop {
+	if x != nil {
+		if x, ok := x.Message.(*BatchSendRequest_Stop_); ok {
+			return x.Stop
+		}
+	}
+	return nil
+}
+
+type isBatchSendRequest_Message interface {
+	isBatchSendRequest_Message()
+}
+
+type BatchSendRequest_Objects_ struct {
+	Objects *BatchSendRequest_Objects `protobuf:"bytes,2,opt,name=objects,proto3,oneof"`
+}
+
+type BatchSendRequest_References_ struct {
+	References *BatchSendRequest_References `protobuf:"bytes,3,opt,name=references,proto3,oneof"`
+}
+
+type BatchSendRequest_Stop_ struct {
+	Stop *BatchSendRequest_Stop `protobuf:"bytes,4,opt,name=stop,proto3,oneof"`
+}
+
+func (*BatchSendRequest_Objects_) isBatchSendRequest_Message() {}
+
+func (*BatchSendRequest_References_) isBatchSendRequest_Message() {}
+
+func (*BatchSendRequest_Stop_) isBatchSendRequest_Message() {}
+
+type BatchSendReply struct {
+	state          protoimpl.MessageState `protogen:"open.v1"`
+	NextBatchSize  int32                  `protobuf:"varint,1,opt,name=next_batch_size,json=nextBatchSize,proto3" json:"next_batch_size,omitempty"`
+	BackoffSeconds float32                `protobuf:"fixed32,2,opt,name=backoff_seconds,json=backoffSeconds,proto3" json:"backoff_seconds,omitempty"`
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
+}
+
+func (x *BatchSendReply) Reset() {
+	*x = BatchSendReply{}
+	mi := &file_v1_batch_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchSendReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchSendReply) ProtoMessage() {}
+
+func (x *BatchSendReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchSendReply.ProtoReflect.Descriptor instead.
+func (*BatchSendReply) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *BatchSendReply) GetNextBatchSize() int32 {
+	if x != nil {
+		return x.NextBatchSize
+	}
+	return 0
+}
+
+func (x *BatchSendReply) GetBackoffSeconds() float32 {
+	if x != nil {
+		return x.BackoffSeconds
+	}
+	return 0
+}
+
+type BatchStreamRequest struct {
+	state            protoimpl.MessageState `protogen:"open.v1"`
+	ConsistencyLevel *ConsistencyLevel      `protobuf:"varint,1,opt,name=consistency_level,json=consistencyLevel,proto3,enum=weaviate.v1.ConsistencyLevel,oneof" json:"consistency_level,omitempty"`
+	ObjectIndex      *int32                 `protobuf:"varint,2,opt,name=object_index,json=objectIndex,proto3,oneof" json:"object_index,omitempty"`
+	ReferenceIndex   *int32                 `protobuf:"varint,3,opt,name=reference_index,json=referenceIndex,proto3,oneof" json:"reference_index,omitempty"`
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *BatchStreamRequest) Reset() {
+	*x = BatchStreamRequest{}
+	mi := &file_v1_batch_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamRequest) ProtoMessage() {}
+
+func (x *BatchStreamRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamRequest.ProtoReflect.Descriptor instead.
+func (*BatchStreamRequest) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *BatchStreamRequest) GetConsistencyLevel() ConsistencyLevel {
+	if x != nil && x.ConsistencyLevel != nil {
+		return *x.ConsistencyLevel
+	}
+	return ConsistencyLevel_CONSISTENCY_LEVEL_UNSPECIFIED
+}
+
+func (x *BatchStreamRequest) GetObjectIndex() int32 {
+	if x != nil && x.ObjectIndex != nil {
+		return *x.ObjectIndex
+	}
+	return 0
+}
+
+func (x *BatchStreamRequest) GetReferenceIndex() int32 {
+	if x != nil && x.ReferenceIndex != nil {
+		return *x.ReferenceIndex
+	}
+	return 0
+}
+
+type BatchStreamMessage struct {
+	state    protoimpl.MessageState `protogen:"open.v1"`
+	StreamId string                 `protobuf:"bytes,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"`
+	// Types that are valid to be assigned to Message:
+	//
+	//	*BatchStreamMessage_Error_
+	//	*BatchStreamMessage_Start_
+	//	*BatchStreamMessage_Stop_
+	//	*BatchStreamMessage_Shutdown_
+	//	*BatchStreamMessage_ShuttingDown_
+	Message       isBatchStreamMessage_Message `protobuf_oneof:"message"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchStreamMessage) Reset() {
+	*x = BatchStreamMessage{}
+	mi := &file_v1_batch_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamMessage) ProtoMessage() {}
+
+func (x *BatchStreamMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamMessage.ProtoReflect.Descriptor instead.
+func (*BatchStreamMessage) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *BatchStreamMessage) GetStreamId() string {
+	if x != nil {
+		return x.StreamId
+	}
+	return ""
+}
+
+func (x *BatchStreamMessage) GetMessage() isBatchStreamMessage_Message {
+	if x != nil {
+		return x.Message
+	}
+	return nil
+}
+
+func (x *BatchStreamMessage) GetError() *BatchStreamMessage_Error {
+	if x != nil {
+		if x, ok := x.Message.(*BatchStreamMessage_Error_); ok {
+			return x.Error
+		}
+	}
+	return nil
+}
+
+func (x *BatchStreamMessage) GetStart() *BatchStreamMessage_Start {
+	if x != nil {
+		if x, ok := x.Message.(*BatchStreamMessage_Start_); ok {
+			return x.Start
+		}
+	}
+	return nil
+}
+
+func (x *BatchStreamMessage) GetStop() *BatchStreamMessage_Stop {
+	if x != nil {
+		if x, ok := x.Message.(*BatchStreamMessage_Stop_); ok {
+			return x.Stop
+		}
+	}
+	return nil
+}
+
+func (x *BatchStreamMessage) GetShutdown() *BatchStreamMessage_Shutdown {
+	if x != nil {
+		if x, ok := x.Message.(*BatchStreamMessage_Shutdown_); ok {
+			return x.Shutdown
+		}
+	}
+	return nil
+}
+
+func (x *BatchStreamMessage) GetShuttingDown() *BatchStreamMessage_ShuttingDown {
+	if x != nil {
+		if x, ok := x.Message.(*BatchStreamMessage_ShuttingDown_); ok {
+			return x.ShuttingDown
+		}
+	}
+	return nil
+}
+
+type isBatchStreamMessage_Message interface {
+	isBatchStreamMessage_Message()
+}
+
+type BatchStreamMessage_Error_ struct {
+	Error *BatchStreamMessage_Error `protobuf:"bytes,2,opt,name=error,proto3,oneof"`
+}
+
+type BatchStreamMessage_Start_ struct {
+	Start *BatchStreamMessage_Start `protobuf:"bytes,3,opt,name=start,proto3,oneof"`
+}
+
+type BatchStreamMessage_Stop_ struct {
+	Stop *BatchStreamMessage_Stop `protobuf:"bytes,4,opt,name=stop,proto3,oneof"`
+}
+
+type BatchStreamMessage_Shutdown_ struct {
+	Shutdown *BatchStreamMessage_Shutdown `protobuf:"bytes,5,opt,name=shutdown,proto3,oneof"`
+}
+
+type BatchStreamMessage_ShuttingDown_ struct {
+	ShuttingDown *BatchStreamMessage_ShuttingDown `protobuf:"bytes,6,opt,name=shutting_down,json=shuttingDown,proto3,oneof"`
+}
+
+func (*BatchStreamMessage_Error_) isBatchStreamMessage_Message() {}
+
+func (*BatchStreamMessage_Start_) isBatchStreamMessage_Message() {}
+
+func (*BatchStreamMessage_Stop_) isBatchStreamMessage_Message() {}
+
+func (*BatchStreamMessage_Shutdown_) isBatchStreamMessage_Message() {}
+
+func (*BatchStreamMessage_ShuttingDown_) isBatchStreamMessage_Message() {}
+
+type BatchObject struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Uuid  string                 `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	//
+	// Deprecated: Marked as deprecated in v1/batch.proto.
+	Vector      []float32               `protobuf:"fixed32,2,rep,packed,name=vector,proto3" json:"vector,omitempty"` // deprecated, will be removed
+	Properties  *BatchObject_Properties `protobuf:"bytes,3,opt,name=properties,proto3" json:"properties,omitempty"`
+	Collection  string                  `protobuf:"bytes,4,opt,name=collection,proto3" json:"collection,omitempty"`
+	Tenant      string                  `protobuf:"bytes,5,opt,name=tenant,proto3" json:"tenant,omitempty"`
+	VectorBytes []byte                  `protobuf:"bytes,6,opt,name=vector_bytes,json=vectorBytes,proto3" json:"vector_bytes,omitempty"`
+	// protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+	Vectors       []*Vectors `protobuf:"bytes,23,rep,name=vectors,proto3" json:"vectors,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchObject) Reset() {
+	*x = BatchObject{}
+	mi := &file_v1_batch_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObject) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObject) ProtoMessage() {}
+
+func (x *BatchObject) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObject.ProtoReflect.Descriptor instead.
+func (*BatchObject) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *BatchObject) GetUuid() string {
+	if x != nil {
+		return x.Uuid
+	}
+	return ""
+}
+
+// Deprecated: Marked as deprecated in v1/batch.proto.
+func (x *BatchObject) GetVector() []float32 {
+	if x != nil {
+		return x.Vector
+	}
+	return nil
+}
+
+func (x *BatchObject) GetProperties() *BatchObject_Properties {
+	if x != nil {
+		return x.Properties
+	}
+	return nil
+}
+
+func (x *BatchObject) GetCollection() string {
+	if x != nil {
+		return x.Collection
+	}
+	return ""
+}
+
+func (x *BatchObject) GetTenant() string {
+	if x != nil {
+		return x.Tenant
+	}
+	return ""
+}
+
+func (x *BatchObject) GetVectorBytes() []byte {
+	if x != nil {
+		return x.VectorBytes
+	}
+	return nil
+}
+
+func (x *BatchObject) GetVectors() []*Vectors {
+	if x != nil {
+		return x.Vectors
+	}
+	return nil
+}
+
+type BatchReference struct {
+	state          protoimpl.MessageState `protogen:"open.v1"`
+	Name           string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	FromCollection string                 `protobuf:"bytes,2,opt,name=from_collection,json=fromCollection,proto3" json:"from_collection,omitempty"`
+	FromUuid       string                 `protobuf:"bytes,3,opt,name=from_uuid,json=fromUuid,proto3" json:"from_uuid,omitempty"`
+	ToCollection   *string                `protobuf:"bytes,4,opt,name=to_collection,json=toCollection,proto3,oneof" json:"to_collection,omitempty"`
+	ToUuid         string                 `protobuf:"bytes,5,opt,name=to_uuid,json=toUuid,proto3" json:"to_uuid,omitempty"`
+	Tenant         string                 `protobuf:"bytes,6,opt,name=tenant,proto3" json:"tenant,omitempty"`
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
+}
+
+func (x *BatchReference) Reset() {
+	*x = BatchReference{}
+	mi := &file_v1_batch_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchReference) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchReference) ProtoMessage() {}
+
+func (x *BatchReference) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchReference.ProtoReflect.Descriptor instead.
+func (*BatchReference) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *BatchReference) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *BatchReference) GetFromCollection() string {
+	if x != nil {
+		return x.FromCollection
+	}
+	return ""
+}
+
+func (x *BatchReference) GetFromUuid() string {
+	if x != nil {
+		return x.FromUuid
+	}
+	return ""
+}
+
+func (x *BatchReference) GetToCollection() string {
+	if x != nil && x.ToCollection != nil {
+		return *x.ToCollection
+	}
+	return ""
+}
+
+func (x *BatchReference) GetToUuid() string {
+	if x != nil {
+		return x.ToUuid
+	}
+	return ""
+}
+
+func (x *BatchReference) GetTenant() string {
+	if x != nil {
+		return x.Tenant
+	}
+	return ""
+}
+
+type BatchObjectsReply struct {
+	state         protoimpl.MessageState          `protogen:"open.v1"`
+	Took          float32                         `protobuf:"fixed32,1,opt,name=took,proto3" json:"took,omitempty"`
+	Errors        []*BatchObjectsReply_BatchError `protobuf:"bytes,2,rep,name=errors,proto3" json:"errors,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchObjectsReply) Reset() {
+	*x = BatchObjectsReply{}
+	mi := &file_v1_batch_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObjectsReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObjectsReply) ProtoMessage() {}
+
+func (x *BatchObjectsReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObjectsReply.ProtoReflect.Descriptor instead.
+func (*BatchObjectsReply) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *BatchObjectsReply) GetTook() float32 {
+	if x != nil {
+		return x.Took
+	}
+	return 0
+}
+
+func (x *BatchObjectsReply) GetErrors() []*BatchObjectsReply_BatchError {
+	if x != nil {
+		return x.Errors
+	}
+	return nil
+}
+
+type BatchReferencesReply struct {
+	state         protoimpl.MessageState             `protogen:"open.v1"`
+	Took          float32                            `protobuf:"fixed32,1,opt,name=took,proto3" json:"took,omitempty"`
+	Errors        []*BatchReferencesReply_BatchError `protobuf:"bytes,2,rep,name=errors,proto3" json:"errors,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchReferencesReply) Reset() {
+	*x = BatchReferencesReply{}
+	mi := &file_v1_batch_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchReferencesReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchReferencesReply) ProtoMessage() {}
+
+func (x *BatchReferencesReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchReferencesReply.ProtoReflect.Descriptor instead.
+func (*BatchReferencesReply) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *BatchReferencesReply) GetTook() float32 {
+	if x != nil {
+		return x.Took
+	}
+	return 0
+}
+
+func (x *BatchReferencesReply) GetErrors() []*BatchReferencesReply_BatchError {
+	if x != nil {
+		return x.Errors
+	}
+	return nil
+}
+
+type BatchSendRequest_Stop struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchSendRequest_Stop) Reset() {
+	*x = BatchSendRequest_Stop{}
+	mi := &file_v1_batch_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchSendRequest_Stop) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchSendRequest_Stop) ProtoMessage() {}
+
+func (x *BatchSendRequest_Stop) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchSendRequest_Stop.ProtoReflect.Descriptor instead.
+func (*BatchSendRequest_Stop) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{2, 0}
+}
+
+type BatchSendRequest_Objects struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Values        []*BatchObject         `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchSendRequest_Objects) Reset() {
+	*x = BatchSendRequest_Objects{}
+	mi := &file_v1_batch_proto_msgTypes[11]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchSendRequest_Objects) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchSendRequest_Objects) ProtoMessage() {}
+
+func (x *BatchSendRequest_Objects) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchSendRequest_Objects.ProtoReflect.Descriptor instead.
+func (*BatchSendRequest_Objects) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{2, 1}
+}
+
+func (x *BatchSendRequest_Objects) GetValues() []*BatchObject {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type BatchSendRequest_References struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Values        []*BatchReference      `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchSendRequest_References) Reset() {
+	*x = BatchSendRequest_References{}
+	mi := &file_v1_batch_proto_msgTypes[12]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchSendRequest_References) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchSendRequest_References) ProtoMessage() {}
+
+func (x *BatchSendRequest_References) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchSendRequest_References.ProtoReflect.Descriptor instead.
+func (*BatchSendRequest_References) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{2, 2}
+}
+
+func (x *BatchSendRequest_References) GetValues() []*BatchReference {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type BatchStreamMessage_Start struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchStreamMessage_Start) Reset() {
+	*x = BatchStreamMessage_Start{}
+	mi := &file_v1_batch_proto_msgTypes[13]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamMessage_Start) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamMessage_Start) ProtoMessage() {}
+
+func (x *BatchStreamMessage_Start) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamMessage_Start.ProtoReflect.Descriptor instead.
+func (*BatchStreamMessage_Start) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{5, 0}
+}
+
+type BatchStreamMessage_Stop struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchStreamMessage_Stop) Reset() {
+	*x = BatchStreamMessage_Stop{}
+	mi := &file_v1_batch_proto_msgTypes[14]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamMessage_Stop) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamMessage_Stop) ProtoMessage() {}
+
+func (x *BatchStreamMessage_Stop) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamMessage_Stop.ProtoReflect.Descriptor instead.
+func (*BatchStreamMessage_Stop) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{5, 1}
+}
+
+type BatchStreamMessage_Shutdown struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchStreamMessage_Shutdown) Reset() {
+	*x = BatchStreamMessage_Shutdown{}
+	mi := &file_v1_batch_proto_msgTypes[15]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamMessage_Shutdown) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamMessage_Shutdown) ProtoMessage() {}
+
+func (x *BatchStreamMessage_Shutdown) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamMessage_Shutdown.ProtoReflect.Descriptor instead.
+func (*BatchStreamMessage_Shutdown) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{5, 2}
+}
+
+type BatchStreamMessage_ShuttingDown struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchStreamMessage_ShuttingDown) Reset() {
+	*x = BatchStreamMessage_ShuttingDown{}
+	mi := &file_v1_batch_proto_msgTypes[16]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamMessage_ShuttingDown) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamMessage_ShuttingDown) ProtoMessage() {}
+
+func (x *BatchStreamMessage_ShuttingDown) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamMessage_ShuttingDown.ProtoReflect.Descriptor instead.
+func (*BatchStreamMessage_ShuttingDown) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{5, 3}
+}
+
+type BatchStreamMessage_Error struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Error         string                 `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
+	Index         int32                  `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
+	IsRetriable   bool                   `protobuf:"varint,3,opt,name=is_retriable,json=isRetriable,proto3" json:"is_retriable,omitempty"`
+	IsObject      bool                   `protobuf:"varint,4,opt,name=is_object,json=isObject,proto3" json:"is_object,omitempty"`
+	IsReference   bool                   `protobuf:"varint,5,opt,name=is_reference,json=isReference,proto3" json:"is_reference,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchStreamMessage_Error) Reset() {
+	*x = BatchStreamMessage_Error{}
+	mi := &file_v1_batch_proto_msgTypes[17]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchStreamMessage_Error) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchStreamMessage_Error) ProtoMessage() {}
+
+func (x *BatchStreamMessage_Error) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchStreamMessage_Error.ProtoReflect.Descriptor instead.
+func (*BatchStreamMessage_Error) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{5, 4}
+}
+
+func (x *BatchStreamMessage_Error) GetError() string {
+	if x != nil {
+		return x.Error
+	}
+	return ""
+}
+
+func (x *BatchStreamMessage_Error) GetIndex() int32 {
+	if x != nil {
+		return x.Index
+	}
+	return 0
+}
+
+func (x *BatchStreamMessage_Error) GetIsRetriable() bool {
+	if x != nil {
+		return x.IsRetriable
+	}
+	return false
+}
+
+func (x *BatchStreamMessage_Error) GetIsObject() bool {
+	if x != nil {
+		return x.IsObject
+	}
+	return false
+}
+
+func (x *BatchStreamMessage_Error) GetIsReference() bool {
+	if x != nil {
+		return x.IsReference
+	}
+	return false
+}
+
+type BatchObject_Properties 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"`
+	SingleTargetRefProps   []*BatchObject_SingleTargetRefProps `protobuf:"bytes,2,rep,name=single_target_ref_props,json=singleTargetRefProps,proto3" json:"single_target_ref_props,omitempty"`
+	MultiTargetRefProps    []*BatchObject_MultiTargetRefProps  `protobuf:"bytes,3,rep,name=multi_target_ref_props,json=multiTargetRefProps,proto3" json:"multi_target_ref_props,omitempty"`
+	NumberArrayProperties  []*NumberArrayProperties            `protobuf:"bytes,4,rep,name=number_array_properties,json=numberArrayProperties,proto3" json:"number_array_properties,omitempty"`
+	IntArrayProperties     []*IntArrayProperties               `protobuf:"bytes,5,rep,name=int_array_properties,json=intArrayProperties,proto3" json:"int_array_properties,omitempty"`
+	TextArrayProperties    []*TextArrayProperties              `protobuf:"bytes,6,rep,name=text_array_properties,json=textArrayProperties,proto3" json:"text_array_properties,omitempty"`
+	BooleanArrayProperties []*BooleanArrayProperties           `protobuf:"bytes,7,rep,name=boolean_array_properties,json=booleanArrayProperties,proto3" json:"boolean_array_properties,omitempty"`
+	ObjectProperties       []*ObjectProperties                 `protobuf:"bytes,8,rep,name=object_properties,json=objectProperties,proto3" json:"object_properties,omitempty"`
+	ObjectArrayProperties  []*ObjectArrayProperties            `protobuf:"bytes,9,rep,name=object_array_properties,json=objectArrayProperties,proto3" json:"object_array_properties,omitempty"`
+	// empty lists do not have a type in many languages and clients do not know which datatype the property has.
+	// Weaviate can get the datatype from its schema
+	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 *BatchObject_Properties) Reset() {
+	*x = BatchObject_Properties{}
+	mi := &file_v1_batch_proto_msgTypes[18]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObject_Properties) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObject_Properties) ProtoMessage() {}
+
+func (x *BatchObject_Properties) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObject_Properties.ProtoReflect.Descriptor instead.
+func (*BatchObject_Properties) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{6, 0}
+}
+
+func (x *BatchObject_Properties) GetNonRefProperties() *structpb.Struct {
+	if x != nil {
+		return x.NonRefProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetSingleTargetRefProps() []*BatchObject_SingleTargetRefProps {
+	if x != nil {
+		return x.SingleTargetRefProps
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetMultiTargetRefProps() []*BatchObject_MultiTargetRefProps {
+	if x != nil {
+		return x.MultiTargetRefProps
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetNumberArrayProperties() []*NumberArrayProperties {
+	if x != nil {
+		return x.NumberArrayProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetIntArrayProperties() []*IntArrayProperties {
+	if x != nil {
+		return x.IntArrayProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetTextArrayProperties() []*TextArrayProperties {
+	if x != nil {
+		return x.TextArrayProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetBooleanArrayProperties() []*BooleanArrayProperties {
+	if x != nil {
+		return x.BooleanArrayProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetObjectProperties() []*ObjectProperties {
+	if x != nil {
+		return x.ObjectProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetObjectArrayProperties() []*ObjectArrayProperties {
+	if x != nil {
+		return x.ObjectArrayProperties
+	}
+	return nil
+}
+
+func (x *BatchObject_Properties) GetEmptyListProps() []string {
+	if x != nil {
+		return x.EmptyListProps
+	}
+	return nil
+}
+
+type BatchObject_SingleTargetRefProps struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Uuids         []string               `protobuf:"bytes,1,rep,name=uuids,proto3" json:"uuids,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 *BatchObject_SingleTargetRefProps) Reset() {
+	*x = BatchObject_SingleTargetRefProps{}
+	mi := &file_v1_batch_proto_msgTypes[19]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObject_SingleTargetRefProps) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObject_SingleTargetRefProps) ProtoMessage() {}
+
+func (x *BatchObject_SingleTargetRefProps) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObject_SingleTargetRefProps.ProtoReflect.Descriptor instead.
+func (*BatchObject_SingleTargetRefProps) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{6, 1}
+}
+
+func (x *BatchObject_SingleTargetRefProps) GetUuids() []string {
+	if x != nil {
+		return x.Uuids
+	}
+	return nil
+}
+
+func (x *BatchObject_SingleTargetRefProps) GetPropName() string {
+	if x != nil {
+		return x.PropName
+	}
+	return ""
+}
+
+type BatchObject_MultiTargetRefProps struct {
+	state            protoimpl.MessageState `protogen:"open.v1"`
+	Uuids            []string               `protobuf:"bytes,1,rep,name=uuids,proto3" json:"uuids,omitempty"`
+	PropName         string                 `protobuf:"bytes,2,opt,name=prop_name,json=propName,proto3" json:"prop_name,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 *BatchObject_MultiTargetRefProps) Reset() {
+	*x = BatchObject_MultiTargetRefProps{}
+	mi := &file_v1_batch_proto_msgTypes[20]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObject_MultiTargetRefProps) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObject_MultiTargetRefProps) ProtoMessage() {}
+
+func (x *BatchObject_MultiTargetRefProps) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObject_MultiTargetRefProps.ProtoReflect.Descriptor instead.
+func (*BatchObject_MultiTargetRefProps) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{6, 2}
+}
+
+func (x *BatchObject_MultiTargetRefProps) GetUuids() []string {
+	if x != nil {
+		return x.Uuids
+	}
+	return nil
+}
+
+func (x *BatchObject_MultiTargetRefProps) GetPropName() string {
+	if x != nil {
+		return x.PropName
+	}
+	return ""
+}
+
+func (x *BatchObject_MultiTargetRefProps) GetTargetCollection() string {
+	if x != nil {
+		return x.TargetCollection
+	}
+	return ""
+}
+
+type BatchObjectsReply_BatchError struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Index         int32                  `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
+	Error         string                 `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchObjectsReply_BatchError) Reset() {
+	*x = BatchObjectsReply_BatchError{}
+	mi := &file_v1_batch_proto_msgTypes[21]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchObjectsReply_BatchError) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchObjectsReply_BatchError) ProtoMessage() {}
+
+func (x *BatchObjectsReply_BatchError) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchObjectsReply_BatchError.ProtoReflect.Descriptor instead.
+func (*BatchObjectsReply_BatchError) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{8, 0}
+}
+
+func (x *BatchObjectsReply_BatchError) GetIndex() int32 {
+	if x != nil {
+		return x.Index
+	}
+	return 0
+}
+
+func (x *BatchObjectsReply_BatchError) GetError() string {
+	if x != nil {
+		return x.Error
+	}
+	return ""
+}
+
+type BatchReferencesReply_BatchError struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Index         int32                  `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
+	Error         string                 `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchReferencesReply_BatchError) Reset() {
+	*x = BatchReferencesReply_BatchError{}
+	mi := &file_v1_batch_proto_msgTypes[22]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchReferencesReply_BatchError) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchReferencesReply_BatchError) ProtoMessage() {}
+
+func (x *BatchReferencesReply_BatchError) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_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 BatchReferencesReply_BatchError.ProtoReflect.Descriptor instead.
+func (*BatchReferencesReply_BatchError) Descriptor() ([]byte, []int) {
+	return file_v1_batch_proto_rawDescGZIP(), []int{9, 0}
+}
+
+func (x *BatchReferencesReply_BatchError) GetIndex() int32 {
+	if x != nil {
+		return x.Index
+	}
+	return 0
+}
+
+func (x *BatchReferencesReply_BatchError) GetError() string {
+	if x != nil {
+		return x.Error
+	}
+	return ""
+}
+
+var File_v1_batch_proto protoreflect.FileDescriptor
+
+const file_v1_batch_proto_rawDesc = "" +
+	"\n" +
+	"\x0ev1/batch.proto\x12\vweaviate.v1\x1a\x1cgoogle/protobuf/struct.proto\x1a\rv1/base.proto\"\xb0\x01\n" +
+	"\x13BatchObjectsRequest\x122\n" +
+	"\aobjects\x18\x01 \x03(\v2\x18.weaviate.v1.BatchObjectR\aobjects\x12O\n" +
+	"\x11consistency_level\x18\x02 \x01(\x0e2\x1d.weaviate.v1.ConsistencyLevelH\x00R\x10consistencyLevel\x88\x01\x01B\x14\n" +
+	"\x12_consistency_level\"\xbc\x01\n" +
+	"\x16BatchReferencesRequest\x12;\n" +
+	"\n" +
+	"references\x18\x01 \x03(\v2\x1b.weaviate.v1.BatchReferenceR\n" +
+	"references\x12O\n" +
+	"\x11consistency_level\x18\x02 \x01(\x0e2\x1d.weaviate.v1.ConsistencyLevelH\x00R\x10consistencyLevel\x88\x01\x01B\x14\n" +
+	"\x12_consistency_level\"\x8b\x03\n" +
+	"\x10BatchSendRequest\x12\x1b\n" +
+	"\tstream_id\x18\x01 \x01(\tR\bstreamId\x12A\n" +
+	"\aobjects\x18\x02 \x01(\v2%.weaviate.v1.BatchSendRequest.ObjectsH\x00R\aobjects\x12J\n" +
+	"\n" +
+	"references\x18\x03 \x01(\v2(.weaviate.v1.BatchSendRequest.ReferencesH\x00R\n" +
+	"references\x128\n" +
+	"\x04stop\x18\x04 \x01(\v2\".weaviate.v1.BatchSendRequest.StopH\x00R\x04stop\x1a\x06\n" +
+	"\x04Stop\x1a;\n" +
+	"\aObjects\x120\n" +
+	"\x06values\x18\x01 \x03(\v2\x18.weaviate.v1.BatchObjectR\x06values\x1aA\n" +
+	"\n" +
+	"References\x123\n" +
+	"\x06values\x18\x01 \x03(\v2\x1b.weaviate.v1.BatchReferenceR\x06valuesB\t\n" +
+	"\amessage\"a\n" +
+	"\x0eBatchSendReply\x12&\n" +
+	"\x0fnext_batch_size\x18\x01 \x01(\x05R\rnextBatchSize\x12'\n" +
+	"\x0fbackoff_seconds\x18\x02 \x01(\x02R\x0ebackoffSeconds\"\xf6\x01\n" +
+	"\x12BatchStreamRequest\x12O\n" +
+	"\x11consistency_level\x18\x01 \x01(\x0e2\x1d.weaviate.v1.ConsistencyLevelH\x00R\x10consistencyLevel\x88\x01\x01\x12&\n" +
+	"\fobject_index\x18\x02 \x01(\x05H\x01R\vobjectIndex\x88\x01\x01\x12,\n" +
+	"\x0freference_index\x18\x03 \x01(\x05H\x02R\x0ereferenceIndex\x88\x01\x01B\x14\n" +
+	"\x12_consistency_levelB\x0f\n" +
+	"\r_object_indexB\x12\n" +
+	"\x10_reference_index\"\xd9\x04\n" +
+	"\x12BatchStreamMessage\x12\x1b\n" +
+	"\tstream_id\x18\x01 \x01(\tR\bstreamId\x12=\n" +
+	"\x05error\x18\x02 \x01(\v2%.weaviate.v1.BatchStreamMessage.ErrorH\x00R\x05error\x12=\n" +
+	"\x05start\x18\x03 \x01(\v2%.weaviate.v1.BatchStreamMessage.StartH\x00R\x05start\x12:\n" +
+	"\x04stop\x18\x04 \x01(\v2$.weaviate.v1.BatchStreamMessage.StopH\x00R\x04stop\x12F\n" +
+	"\bshutdown\x18\x05 \x01(\v2(.weaviate.v1.BatchStreamMessage.ShutdownH\x00R\bshutdown\x12S\n" +
+	"\rshutting_down\x18\x06 \x01(\v2,.weaviate.v1.BatchStreamMessage.ShuttingDownH\x00R\fshuttingDown\x1a\a\n" +
+	"\x05Start\x1a\x06\n" +
+	"\x04Stop\x1a\n" +
+	"\n" +
+	"\bShutdown\x1a\x0e\n" +
+	"\fShuttingDown\x1a\x96\x01\n" +
+	"\x05Error\x12\x14\n" +
+	"\x05error\x18\x01 \x01(\tR\x05error\x12\x14\n" +
+	"\x05index\x18\x02 \x01(\x05R\x05index\x12!\n" +
+	"\fis_retriable\x18\x03 \x01(\bR\visRetriable\x12\x1b\n" +
+	"\tis_object\x18\x04 \x01(\bR\bisObject\x12!\n" +
+	"\fis_reference\x18\x05 \x01(\bR\visReferenceB\t\n" +
+	"\amessage\"\xa4\n" +
+	"\n" +
+	"\vBatchObject\x12\x12\n" +
+	"\x04uuid\x18\x01 \x01(\tR\x04uuid\x12\x1a\n" +
+	"\x06vector\x18\x02 \x03(\x02B\x02\x18\x01R\x06vector\x12C\n" +
+	"\n" +
+	"properties\x18\x03 \x01(\v2#.weaviate.v1.BatchObject.PropertiesR\n" +
+	"properties\x12\x1e\n" +
+	"\n" +
+	"collection\x18\x04 \x01(\tR\n" +
+	"collection\x12\x16\n" +
+	"\x06tenant\x18\x05 \x01(\tR\x06tenant\x12!\n" +
+	"\fvector_bytes\x18\x06 \x01(\fR\vvectorBytes\x12.\n" +
+	"\avectors\x18\x17 \x03(\v2\x14.weaviate.v1.VectorsR\avectors\x1a\xd2\x06\n" +
+	"\n" +
+	"Properties\x12E\n" +
+	"\x12non_ref_properties\x18\x01 \x01(\v2\x17.google.protobuf.StructR\x10nonRefProperties\x12d\n" +
+	"\x17single_target_ref_props\x18\x02 \x03(\v2-.weaviate.v1.BatchObject.SingleTargetRefPropsR\x14singleTargetRefProps\x12a\n" +
+	"\x16multi_target_ref_props\x18\x03 \x03(\v2,.weaviate.v1.BatchObject.MultiTargetRefPropsR\x13multiTargetRefProps\x12Z\n" +
+	"\x17number_array_properties\x18\x04 \x03(\v2\".weaviate.v1.NumberArrayPropertiesR\x15numberArrayProperties\x12Q\n" +
+	"\x14int_array_properties\x18\x05 \x03(\v2\x1f.weaviate.v1.IntArrayPropertiesR\x12intArrayProperties\x12T\n" +
+	"\x15text_array_properties\x18\x06 \x03(\v2 .weaviate.v1.TextArrayPropertiesR\x13textArrayProperties\x12]\n" +
+	"\x18boolean_array_properties\x18\a \x03(\v2#.weaviate.v1.BooleanArrayPropertiesR\x16booleanArrayProperties\x12J\n" +
+	"\x11object_properties\x18\b \x03(\v2\x1d.weaviate.v1.ObjectPropertiesR\x10objectProperties\x12Z\n" +
+	"\x17object_array_properties\x18\t \x03(\v2\".weaviate.v1.ObjectArrayPropertiesR\x15objectArrayProperties\x12(\n" +
+	"\x10empty_list_props\x18\n" +
+	" \x03(\tR\x0eemptyListProps\x1aI\n" +
+	"\x14SingleTargetRefProps\x12\x14\n" +
+	"\x05uuids\x18\x01 \x03(\tR\x05uuids\x12\x1b\n" +
+	"\tprop_name\x18\x02 \x01(\tR\bpropName\x1au\n" +
+	"\x13MultiTargetRefProps\x12\x14\n" +
+	"\x05uuids\x18\x01 \x03(\tR\x05uuids\x12\x1b\n" +
+	"\tprop_name\x18\x02 \x01(\tR\bpropName\x12+\n" +
+	"\x11target_collection\x18\x03 \x01(\tR\x10targetCollection\"\xd7\x01\n" +
+	"\x0eBatchReference\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12'\n" +
+	"\x0ffrom_collection\x18\x02 \x01(\tR\x0efromCollection\x12\x1b\n" +
+	"\tfrom_uuid\x18\x03 \x01(\tR\bfromUuid\x12(\n" +
+	"\rto_collection\x18\x04 \x01(\tH\x00R\ftoCollection\x88\x01\x01\x12\x17\n" +
+	"\ato_uuid\x18\x05 \x01(\tR\x06toUuid\x12\x16\n" +
+	"\x06tenant\x18\x06 \x01(\tR\x06tenantB\x10\n" +
+	"\x0e_to_collection\"\xa4\x01\n" +
+	"\x11BatchObjectsReply\x12\x12\n" +
+	"\x04took\x18\x01 \x01(\x02R\x04took\x12A\n" +
+	"\x06errors\x18\x02 \x03(\v2).weaviate.v1.BatchObjectsReply.BatchErrorR\x06errors\x1a8\n" +
+	"\n" +
+	"BatchError\x12\x14\n" +
+	"\x05index\x18\x01 \x01(\x05R\x05index\x12\x14\n" +
+	"\x05error\x18\x02 \x01(\tR\x05error\"\xaa\x01\n" +
+	"\x14BatchReferencesReply\x12\x12\n" +
+	"\x04took\x18\x01 \x01(\x02R\x04took\x12D\n" +
+	"\x06errors\x18\x02 \x03(\v2,.weaviate.v1.BatchReferencesReply.BatchErrorR\x06errors\x1a8\n" +
+	"\n" +
+	"BatchError\x12\x14\n" +
+	"\x05index\x18\x01 \x01(\x05R\x05index\x12\x14\n" +
+	"\x05error\x18\x02 \x01(\tR\x05errorBo\n" +
+	"#io.weaviate.client.grpc.protocol.v1B\x12WeaviateProtoBatchZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v1_batch_proto_rawDescOnce sync.Once
+	file_v1_batch_proto_rawDescData []byte
+)
+
+func file_v1_batch_proto_rawDescGZIP() []byte {
+	file_v1_batch_proto_rawDescOnce.Do(func() {
+		file_v1_batch_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_batch_proto_rawDesc), len(file_v1_batch_proto_rawDesc)))
+	})
+	return file_v1_batch_proto_rawDescData
+}
+
+var file_v1_batch_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
+var file_v1_batch_proto_goTypes = []any{
+	(*BatchObjectsRequest)(nil),              // 0: weaviate.v1.BatchObjectsRequest
+	(*BatchReferencesRequest)(nil),           // 1: weaviate.v1.BatchReferencesRequest
+	(*BatchSendRequest)(nil),                 // 2: weaviate.v1.BatchSendRequest
+	(*BatchSendReply)(nil),                   // 3: weaviate.v1.BatchSendReply
+	(*BatchStreamRequest)(nil),               // 4: weaviate.v1.BatchStreamRequest
+	(*BatchStreamMessage)(nil),               // 5: weaviate.v1.BatchStreamMessage
+	(*BatchObject)(nil),                      // 6: weaviate.v1.BatchObject
+	(*BatchReference)(nil),                   // 7: weaviate.v1.BatchReference
+	(*BatchObjectsReply)(nil),                // 8: weaviate.v1.BatchObjectsReply
+	(*BatchReferencesReply)(nil),             // 9: weaviate.v1.BatchReferencesReply
+	(*BatchSendRequest_Stop)(nil),            // 10: weaviate.v1.BatchSendRequest.Stop
+	(*BatchSendRequest_Objects)(nil),         // 11: weaviate.v1.BatchSendRequest.Objects
+	(*BatchSendRequest_References)(nil),      // 12: weaviate.v1.BatchSendRequest.References
+	(*BatchStreamMessage_Start)(nil),         // 13: weaviate.v1.BatchStreamMessage.Start
+	(*BatchStreamMessage_Stop)(nil),          // 14: weaviate.v1.BatchStreamMessage.Stop
+	(*BatchStreamMessage_Shutdown)(nil),      // 15: weaviate.v1.BatchStreamMessage.Shutdown
+	(*BatchStreamMessage_ShuttingDown)(nil),  // 16: weaviate.v1.BatchStreamMessage.ShuttingDown
+	(*BatchStreamMessage_Error)(nil),         // 17: weaviate.v1.BatchStreamMessage.Error
+	(*BatchObject_Properties)(nil),           // 18: weaviate.v1.BatchObject.Properties
+	(*BatchObject_SingleTargetRefProps)(nil), // 19: weaviate.v1.BatchObject.SingleTargetRefProps
+	(*BatchObject_MultiTargetRefProps)(nil),  // 20: weaviate.v1.BatchObject.MultiTargetRefProps
+	(*BatchObjectsReply_BatchError)(nil),     // 21: weaviate.v1.BatchObjectsReply.BatchError
+	(*BatchReferencesReply_BatchError)(nil),  // 22: weaviate.v1.BatchReferencesReply.BatchError
+	(ConsistencyLevel)(0),                    // 23: weaviate.v1.ConsistencyLevel
+	(*Vectors)(nil),                          // 24: weaviate.v1.Vectors
+	(*structpb.Struct)(nil),                  // 25: google.protobuf.Struct
+	(*NumberArrayProperties)(nil),            // 26: weaviate.v1.NumberArrayProperties
+	(*IntArrayProperties)(nil),               // 27: weaviate.v1.IntArrayProperties
+	(*TextArrayProperties)(nil),              // 28: weaviate.v1.TextArrayProperties
+	(*BooleanArrayProperties)(nil),           // 29: weaviate.v1.BooleanArrayProperties
+	(*ObjectProperties)(nil),                 // 30: weaviate.v1.ObjectProperties
+	(*ObjectArrayProperties)(nil),            // 31: weaviate.v1.ObjectArrayProperties
+}
+var file_v1_batch_proto_depIdxs = []int32{
+	6,  // 0: weaviate.v1.BatchObjectsRequest.objects:type_name -> weaviate.v1.BatchObject
+	23, // 1: weaviate.v1.BatchObjectsRequest.consistency_level:type_name -> weaviate.v1.ConsistencyLevel
+	7,  // 2: weaviate.v1.BatchReferencesRequest.references:type_name -> weaviate.v1.BatchReference
+	23, // 3: weaviate.v1.BatchReferencesRequest.consistency_level:type_name -> weaviate.v1.ConsistencyLevel
+	11, // 4: weaviate.v1.BatchSendRequest.objects:type_name -> weaviate.v1.BatchSendRequest.Objects
+	12, // 5: weaviate.v1.BatchSendRequest.references:type_name -> weaviate.v1.BatchSendRequest.References
+	10, // 6: weaviate.v1.BatchSendRequest.stop:type_name -> weaviate.v1.BatchSendRequest.Stop
+	23, // 7: weaviate.v1.BatchStreamRequest.consistency_level:type_name -> weaviate.v1.ConsistencyLevel
+	17, // 8: weaviate.v1.BatchStreamMessage.error:type_name -> weaviate.v1.BatchStreamMessage.Error
+	13, // 9: weaviate.v1.BatchStreamMessage.start:type_name -> weaviate.v1.BatchStreamMessage.Start
+	14, // 10: weaviate.v1.BatchStreamMessage.stop:type_name -> weaviate.v1.BatchStreamMessage.Stop
+	15, // 11: weaviate.v1.BatchStreamMessage.shutdown:type_name -> weaviate.v1.BatchStreamMessage.Shutdown
+	16, // 12: weaviate.v1.BatchStreamMessage.shutting_down:type_name -> weaviate.v1.BatchStreamMessage.ShuttingDown
+	18, // 13: weaviate.v1.BatchObject.properties:type_name -> weaviate.v1.BatchObject.Properties
+	24, // 14: weaviate.v1.BatchObject.vectors:type_name -> weaviate.v1.Vectors
+	21, // 15: weaviate.v1.BatchObjectsReply.errors:type_name -> weaviate.v1.BatchObjectsReply.BatchError
+	22, // 16: weaviate.v1.BatchReferencesReply.errors:type_name -> weaviate.v1.BatchReferencesReply.BatchError
+	6,  // 17: weaviate.v1.BatchSendRequest.Objects.values:type_name -> weaviate.v1.BatchObject
+	7,  // 18: weaviate.v1.BatchSendRequest.References.values:type_name -> weaviate.v1.BatchReference
+	25, // 19: weaviate.v1.BatchObject.Properties.non_ref_properties:type_name -> google.protobuf.Struct
+	19, // 20: weaviate.v1.BatchObject.Properties.single_target_ref_props:type_name -> weaviate.v1.BatchObject.SingleTargetRefProps
+	20, // 21: weaviate.v1.BatchObject.Properties.multi_target_ref_props:type_name -> weaviate.v1.BatchObject.MultiTargetRefProps
+	26, // 22: weaviate.v1.BatchObject.Properties.number_array_properties:type_name -> weaviate.v1.NumberArrayProperties
+	27, // 23: weaviate.v1.BatchObject.Properties.int_array_properties:type_name -> weaviate.v1.IntArrayProperties
+	28, // 24: weaviate.v1.BatchObject.Properties.text_array_properties:type_name -> weaviate.v1.TextArrayProperties
+	29, // 25: weaviate.v1.BatchObject.Properties.boolean_array_properties:type_name -> weaviate.v1.BooleanArrayProperties
+	30, // 26: weaviate.v1.BatchObject.Properties.object_properties:type_name -> weaviate.v1.ObjectProperties
+	31, // 27: weaviate.v1.BatchObject.Properties.object_array_properties:type_name -> weaviate.v1.ObjectArrayProperties
+	28, // [28:28] is the sub-list for method output_type
+	28, // [28:28] is the sub-list for method input_type
+	28, // [28:28] is the sub-list for extension type_name
+	28, // [28:28] is the sub-list for extension extendee
+	0,  // [0:28] is the sub-list for field type_name
+}
+
+func init() { file_v1_batch_proto_init() }
+func file_v1_batch_proto_init() {
+	if File_v1_batch_proto != nil {
+		return
+	}
+	file_v1_base_proto_init()
+	file_v1_batch_proto_msgTypes[0].OneofWrappers = []any{}
+	file_v1_batch_proto_msgTypes[1].OneofWrappers = []any{}
+	file_v1_batch_proto_msgTypes[2].OneofWrappers = []any{
+		(*BatchSendRequest_Objects_)(nil),
+		(*BatchSendRequest_References_)(nil),
+		(*BatchSendRequest_Stop_)(nil),
+	}
+	file_v1_batch_proto_msgTypes[4].OneofWrappers = []any{}
+	file_v1_batch_proto_msgTypes[5].OneofWrappers = []any{
+		(*BatchStreamMessage_Error_)(nil),
+		(*BatchStreamMessage_Start_)(nil),
+		(*BatchStreamMessage_Stop_)(nil),
+		(*BatchStreamMessage_Shutdown_)(nil),
+		(*BatchStreamMessage_ShuttingDown_)(nil),
+	}
+	file_v1_batch_proto_msgTypes[7].OneofWrappers = []any{}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_batch_proto_rawDesc), len(file_v1_batch_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   23,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v1_batch_proto_goTypes,
+		DependencyIndexes: file_v1_batch_proto_depIdxs,
+		MessageInfos:      file_v1_batch_proto_msgTypes,
+	}.Build()
+	File_v1_batch_proto = out.File
+	file_v1_batch_proto_goTypes = nil
+	file_v1_batch_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/batch_delete.pb.go

@@ -0,0 +1,330 @@
+// 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"
+)
+
+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 BatchDeleteRequest struct {
+	state            protoimpl.MessageState `protogen:"open.v1"`
+	Collection       string                 `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
+	Filters          *Filters               `protobuf:"bytes,2,opt,name=filters,proto3" json:"filters,omitempty"`
+	Verbose          bool                   `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"`
+	DryRun           bool                   `protobuf:"varint,4,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
+	ConsistencyLevel *ConsistencyLevel      `protobuf:"varint,5,opt,name=consistency_level,json=consistencyLevel,proto3,enum=weaviate.v1.ConsistencyLevel,oneof" json:"consistency_level,omitempty"`
+	Tenant           *string                `protobuf:"bytes,6,opt,name=tenant,proto3,oneof" json:"tenant,omitempty"`
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *BatchDeleteRequest) Reset() {
+	*x = BatchDeleteRequest{}
+	mi := &file_v1_batch_delete_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchDeleteRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchDeleteRequest) ProtoMessage() {}
+
+func (x *BatchDeleteRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_delete_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 BatchDeleteRequest.ProtoReflect.Descriptor instead.
+func (*BatchDeleteRequest) Descriptor() ([]byte, []int) {
+	return file_v1_batch_delete_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *BatchDeleteRequest) GetCollection() string {
+	if x != nil {
+		return x.Collection
+	}
+	return ""
+}
+
+func (x *BatchDeleteRequest) GetFilters() *Filters {
+	if x != nil {
+		return x.Filters
+	}
+	return nil
+}
+
+func (x *BatchDeleteRequest) GetVerbose() bool {
+	if x != nil {
+		return x.Verbose
+	}
+	return false
+}
+
+func (x *BatchDeleteRequest) GetDryRun() bool {
+	if x != nil {
+		return x.DryRun
+	}
+	return false
+}
+
+func (x *BatchDeleteRequest) GetConsistencyLevel() ConsistencyLevel {
+	if x != nil && x.ConsistencyLevel != nil {
+		return *x.ConsistencyLevel
+	}
+	return ConsistencyLevel_CONSISTENCY_LEVEL_UNSPECIFIED
+}
+
+func (x *BatchDeleteRequest) GetTenant() string {
+	if x != nil && x.Tenant != nil {
+		return *x.Tenant
+	}
+	return ""
+}
+
+type BatchDeleteReply struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Took          float32                `protobuf:"fixed32,1,opt,name=took,proto3" json:"took,omitempty"`
+	Failed        int64                  `protobuf:"varint,2,opt,name=failed,proto3" json:"failed,omitempty"`
+	Matches       int64                  `protobuf:"varint,3,opt,name=matches,proto3" json:"matches,omitempty"`
+	Successful    int64                  `protobuf:"varint,4,opt,name=successful,proto3" json:"successful,omitempty"`
+	Objects       []*BatchDeleteObject   `protobuf:"bytes,5,rep,name=objects,proto3" json:"objects,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchDeleteReply) Reset() {
+	*x = BatchDeleteReply{}
+	mi := &file_v1_batch_delete_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchDeleteReply) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchDeleteReply) ProtoMessage() {}
+
+func (x *BatchDeleteReply) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_delete_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 BatchDeleteReply.ProtoReflect.Descriptor instead.
+func (*BatchDeleteReply) Descriptor() ([]byte, []int) {
+	return file_v1_batch_delete_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *BatchDeleteReply) GetTook() float32 {
+	if x != nil {
+		return x.Took
+	}
+	return 0
+}
+
+func (x *BatchDeleteReply) GetFailed() int64 {
+	if x != nil {
+		return x.Failed
+	}
+	return 0
+}
+
+func (x *BatchDeleteReply) GetMatches() int64 {
+	if x != nil {
+		return x.Matches
+	}
+	return 0
+}
+
+func (x *BatchDeleteReply) GetSuccessful() int64 {
+	if x != nil {
+		return x.Successful
+	}
+	return 0
+}
+
+func (x *BatchDeleteReply) GetObjects() []*BatchDeleteObject {
+	if x != nil {
+		return x.Objects
+	}
+	return nil
+}
+
+type BatchDeleteObject struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Uuid          []byte                 `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
+	Successful    bool                   `protobuf:"varint,2,opt,name=successful,proto3" json:"successful,omitempty"`
+	Error         *string                `protobuf:"bytes,3,opt,name=error,proto3,oneof" json:"error,omitempty"` // empty string means no error
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchDeleteObject) Reset() {
+	*x = BatchDeleteObject{}
+	mi := &file_v1_batch_delete_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchDeleteObject) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchDeleteObject) ProtoMessage() {}
+
+func (x *BatchDeleteObject) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_batch_delete_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 BatchDeleteObject.ProtoReflect.Descriptor instead.
+func (*BatchDeleteObject) Descriptor() ([]byte, []int) {
+	return file_v1_batch_delete_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *BatchDeleteObject) GetUuid() []byte {
+	if x != nil {
+		return x.Uuid
+	}
+	return nil
+}
+
+func (x *BatchDeleteObject) GetSuccessful() bool {
+	if x != nil {
+		return x.Successful
+	}
+	return false
+}
+
+func (x *BatchDeleteObject) GetError() string {
+	if x != nil && x.Error != nil {
+		return *x.Error
+	}
+	return ""
+}
+
+var File_v1_batch_delete_proto protoreflect.FileDescriptor
+
+const file_v1_batch_delete_proto_rawDesc = "" +
+	"\n" +
+	"\x15v1/batch_delete.proto\x12\vweaviate.v1\x1a\rv1/base.proto\"\xa6\x02\n" +
+	"\x12BatchDeleteRequest\x12\x1e\n" +
+	"\n" +
+	"collection\x18\x01 \x01(\tR\n" +
+	"collection\x12.\n" +
+	"\afilters\x18\x02 \x01(\v2\x14.weaviate.v1.FiltersR\afilters\x12\x18\n" +
+	"\averbose\x18\x03 \x01(\bR\averbose\x12\x17\n" +
+	"\adry_run\x18\x04 \x01(\bR\x06dryRun\x12O\n" +
+	"\x11consistency_level\x18\x05 \x01(\x0e2\x1d.weaviate.v1.ConsistencyLevelH\x00R\x10consistencyLevel\x88\x01\x01\x12\x1b\n" +
+	"\x06tenant\x18\x06 \x01(\tH\x01R\x06tenant\x88\x01\x01B\x14\n" +
+	"\x12_consistency_levelB\t\n" +
+	"\a_tenant\"\xb2\x01\n" +
+	"\x10BatchDeleteReply\x12\x12\n" +
+	"\x04took\x18\x01 \x01(\x02R\x04took\x12\x16\n" +
+	"\x06failed\x18\x02 \x01(\x03R\x06failed\x12\x18\n" +
+	"\amatches\x18\x03 \x01(\x03R\amatches\x12\x1e\n" +
+	"\n" +
+	"successful\x18\x04 \x01(\x03R\n" +
+	"successful\x128\n" +
+	"\aobjects\x18\x05 \x03(\v2\x1e.weaviate.v1.BatchDeleteObjectR\aobjects\"l\n" +
+	"\x11BatchDeleteObject\x12\x12\n" +
+	"\x04uuid\x18\x01 \x01(\fR\x04uuid\x12\x1e\n" +
+	"\n" +
+	"successful\x18\x02 \x01(\bR\n" +
+	"successful\x12\x19\n" +
+	"\x05error\x18\x03 \x01(\tH\x00R\x05error\x88\x01\x01B\b\n" +
+	"\x06_errorBu\n" +
+	"#io.weaviate.client.grpc.protocol.v1B\x18WeaviateProtoBatchDeleteZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v1_batch_delete_proto_rawDescOnce sync.Once
+	file_v1_batch_delete_proto_rawDescData []byte
+)
+
+func file_v1_batch_delete_proto_rawDescGZIP() []byte {
+	file_v1_batch_delete_proto_rawDescOnce.Do(func() {
+		file_v1_batch_delete_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_batch_delete_proto_rawDesc), len(file_v1_batch_delete_proto_rawDesc)))
+	})
+	return file_v1_batch_delete_proto_rawDescData
+}
+
+var file_v1_batch_delete_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_v1_batch_delete_proto_goTypes = []any{
+	(*BatchDeleteRequest)(nil), // 0: weaviate.v1.BatchDeleteRequest
+	(*BatchDeleteReply)(nil),   // 1: weaviate.v1.BatchDeleteReply
+	(*BatchDeleteObject)(nil),  // 2: weaviate.v1.BatchDeleteObject
+	(*Filters)(nil),            // 3: weaviate.v1.Filters
+	(ConsistencyLevel)(0),      // 4: weaviate.v1.ConsistencyLevel
+}
+var file_v1_batch_delete_proto_depIdxs = []int32{
+	3, // 0: weaviate.v1.BatchDeleteRequest.filters:type_name -> weaviate.v1.Filters
+	4, // 1: weaviate.v1.BatchDeleteRequest.consistency_level:type_name -> weaviate.v1.ConsistencyLevel
+	2, // 2: weaviate.v1.BatchDeleteReply.objects:type_name -> weaviate.v1.BatchDeleteObject
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_v1_batch_delete_proto_init() }
+func file_v1_batch_delete_proto_init() {
+	if File_v1_batch_delete_proto != nil {
+		return
+	}
+	file_v1_base_proto_init()
+	file_v1_batch_delete_proto_msgTypes[0].OneofWrappers = []any{}
+	file_v1_batch_delete_proto_msgTypes[2].OneofWrappers = []any{}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_batch_delete_proto_rawDesc), len(file_v1_batch_delete_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   3,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v1_batch_delete_proto_goTypes,
+		DependencyIndexes: file_v1_batch_delete_proto_depIdxs,
+		MessageInfos:      file_v1_batch_delete_proto_msgTypes,
+	}.Build()
+	File_v1_batch_delete_proto = out.File
+	file_v1_batch_delete_proto_goTypes = nil
+	file_v1_batch_delete_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/file_replication.pb.go

@@ -0,0 +1,810 @@
+// 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"
+)
+
+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 CompressionType int32
+
+const (
+	CompressionType_COMPRESSION_TYPE_UNSPECIFIED CompressionType = 0 // No compression
+	CompressionType_COMPRESSION_TYPE_GZIP        CompressionType = 1 // gzip (compress/gzip)
+	CompressionType_COMPRESSION_TYPE_ZLIB        CompressionType = 2 // zlib (compress/zlib)
+	CompressionType_COMPRESSION_TYPE_DEFLATE     CompressionType = 3 // raw DEFLATE (compress/flate)
+)
+
+// Enum value maps for CompressionType.
+var (
+	CompressionType_name = map[int32]string{
+		0: "COMPRESSION_TYPE_UNSPECIFIED",
+		1: "COMPRESSION_TYPE_GZIP",
+		2: "COMPRESSION_TYPE_ZLIB",
+		3: "COMPRESSION_TYPE_DEFLATE",
+	}
+	CompressionType_value = map[string]int32{
+		"COMPRESSION_TYPE_UNSPECIFIED": 0,
+		"COMPRESSION_TYPE_GZIP":        1,
+		"COMPRESSION_TYPE_ZLIB":        2,
+		"COMPRESSION_TYPE_DEFLATE":     3,
+	}
+)
+
+func (x CompressionType) Enum() *CompressionType {
+	p := new(CompressionType)
+	*p = x
+	return p
+}
+
+func (x CompressionType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CompressionType) Descriptor() protoreflect.EnumDescriptor {
+	return file_v1_file_replication_proto_enumTypes[0].Descriptor()
+}
+
+func (CompressionType) Type() protoreflect.EnumType {
+	return &file_v1_file_replication_proto_enumTypes[0]
+}
+
+func (x CompressionType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use CompressionType.Descriptor instead.
+func (CompressionType) EnumDescriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{0}
+}
+
+type PauseFileActivityRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	SchemaVersion uint64                 `protobuf:"varint,3,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *PauseFileActivityRequest) Reset() {
+	*x = PauseFileActivityRequest{}
+	mi := &file_v1_file_replication_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *PauseFileActivityRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PauseFileActivityRequest) ProtoMessage() {}
+
+func (x *PauseFileActivityRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 PauseFileActivityRequest.ProtoReflect.Descriptor instead.
+func (*PauseFileActivityRequest) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *PauseFileActivityRequest) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *PauseFileActivityRequest) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+func (x *PauseFileActivityRequest) GetSchemaVersion() uint64 {
+	if x != nil {
+		return x.SchemaVersion
+	}
+	return 0
+}
+
+type PauseFileActivityResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *PauseFileActivityResponse) Reset() {
+	*x = PauseFileActivityResponse{}
+	mi := &file_v1_file_replication_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *PauseFileActivityResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PauseFileActivityResponse) ProtoMessage() {}
+
+func (x *PauseFileActivityResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 PauseFileActivityResponse.ProtoReflect.Descriptor instead.
+func (*PauseFileActivityResponse) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *PauseFileActivityResponse) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *PauseFileActivityResponse) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+type ResumeFileActivityRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ResumeFileActivityRequest) Reset() {
+	*x = ResumeFileActivityRequest{}
+	mi := &file_v1_file_replication_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ResumeFileActivityRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ResumeFileActivityRequest) ProtoMessage() {}
+
+func (x *ResumeFileActivityRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 ResumeFileActivityRequest.ProtoReflect.Descriptor instead.
+func (*ResumeFileActivityRequest) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ResumeFileActivityRequest) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *ResumeFileActivityRequest) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+type ResumeFileActivityResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ResumeFileActivityResponse) Reset() {
+	*x = ResumeFileActivityResponse{}
+	mi := &file_v1_file_replication_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ResumeFileActivityResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ResumeFileActivityResponse) ProtoMessage() {}
+
+func (x *ResumeFileActivityResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 ResumeFileActivityResponse.ProtoReflect.Descriptor instead.
+func (*ResumeFileActivityResponse) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *ResumeFileActivityResponse) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *ResumeFileActivityResponse) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+type ListFilesRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListFilesRequest) Reset() {
+	*x = ListFilesRequest{}
+	mi := &file_v1_file_replication_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListFilesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListFilesRequest) ProtoMessage() {}
+
+func (x *ListFilesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 ListFilesRequest.ProtoReflect.Descriptor instead.
+func (*ListFilesRequest) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *ListFilesRequest) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *ListFilesRequest) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+type ListFilesResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	FileNames     []string               `protobuf:"bytes,3,rep,name=file_names,json=fileNames,proto3" json:"file_names,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListFilesResponse) Reset() {
+	*x = ListFilesResponse{}
+	mi := &file_v1_file_replication_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListFilesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListFilesResponse) ProtoMessage() {}
+
+func (x *ListFilesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 ListFilesResponse.ProtoReflect.Descriptor instead.
+func (*ListFilesResponse) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *ListFilesResponse) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *ListFilesResponse) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+func (x *ListFilesResponse) GetFileNames() []string {
+	if x != nil {
+		return x.FileNames
+	}
+	return nil
+}
+
+type GetFileMetadataRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	FileName      string                 `protobuf:"bytes,3,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetFileMetadataRequest) Reset() {
+	*x = GetFileMetadataRequest{}
+	mi := &file_v1_file_replication_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetFileMetadataRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetFileMetadataRequest) ProtoMessage() {}
+
+func (x *GetFileMetadataRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 GetFileMetadataRequest.ProtoReflect.Descriptor instead.
+func (*GetFileMetadataRequest) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *GetFileMetadataRequest) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *GetFileMetadataRequest) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+func (x *GetFileMetadataRequest) GetFileName() string {
+	if x != nil {
+		return x.FileName
+	}
+	return ""
+}
+
+type FileMetadata struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	FileName      string                 `protobuf:"bytes,3,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
+	Size          int64                  `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
+	Crc32         uint32                 `protobuf:"varint,5,opt,name=crc32,proto3" json:"crc32,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *FileMetadata) Reset() {
+	*x = FileMetadata{}
+	mi := &file_v1_file_replication_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *FileMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FileMetadata) ProtoMessage() {}
+
+func (x *FileMetadata) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 FileMetadata.ProtoReflect.Descriptor instead.
+func (*FileMetadata) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *FileMetadata) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *FileMetadata) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+func (x *FileMetadata) GetFileName() string {
+	if x != nil {
+		return x.FileName
+	}
+	return ""
+}
+
+func (x *FileMetadata) GetSize() int64 {
+	if x != nil {
+		return x.Size
+	}
+	return 0
+}
+
+func (x *FileMetadata) GetCrc32() uint32 {
+	if x != nil {
+		return x.Crc32
+	}
+	return 0
+}
+
+type GetFileRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	IndexName     string                 `protobuf:"bytes,1,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
+	ShardName     string                 `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
+	FileName      string                 `protobuf:"bytes,3,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
+	Compression   CompressionType        `protobuf:"varint,4,opt,name=compression,proto3,enum=weaviate.v1.CompressionType" json:"compression,omitempty"` // Requested compression algorithm for streamed chunks
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetFileRequest) Reset() {
+	*x = GetFileRequest{}
+	mi := &file_v1_file_replication_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetFileRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetFileRequest) ProtoMessage() {}
+
+func (x *GetFileRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 GetFileRequest.ProtoReflect.Descriptor instead.
+func (*GetFileRequest) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *GetFileRequest) GetIndexName() string {
+	if x != nil {
+		return x.IndexName
+	}
+	return ""
+}
+
+func (x *GetFileRequest) GetShardName() string {
+	if x != nil {
+		return x.ShardName
+	}
+	return ""
+}
+
+func (x *GetFileRequest) GetFileName() string {
+	if x != nil {
+		return x.FileName
+	}
+	return ""
+}
+
+func (x *GetFileRequest) GetCompression() CompressionType {
+	if x != nil {
+		return x.Compression
+	}
+	return CompressionType_COMPRESSION_TYPE_UNSPECIFIED
+}
+
+type FileChunk struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Offset        int64                  `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` // Byte offset in the uncompressed file
+	Data          []byte                 `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`      // Compressed or raw chunk data
+	Eof           bool                   `protobuf:"varint,3,opt,name=eof,proto3" json:"eof,omitempty"`       // Indicates final chunk
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *FileChunk) Reset() {
+	*x = FileChunk{}
+	mi := &file_v1_file_replication_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *FileChunk) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FileChunk) ProtoMessage() {}
+
+func (x *FileChunk) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_file_replication_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 FileChunk.ProtoReflect.Descriptor instead.
+func (*FileChunk) Descriptor() ([]byte, []int) {
+	return file_v1_file_replication_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *FileChunk) GetOffset() int64 {
+	if x != nil {
+		return x.Offset
+	}
+	return 0
+}
+
+func (x *FileChunk) GetData() []byte {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+func (x *FileChunk) GetEof() bool {
+	if x != nil {
+		return x.Eof
+	}
+	return false
+}
+
+var File_v1_file_replication_proto protoreflect.FileDescriptor
+
+const file_v1_file_replication_proto_rawDesc = "" +
+	"\n" +
+	"\x19v1/file_replication.proto\x12\vweaviate.v1\"\x7f\n" +
+	"\x18PauseFileActivityRequest\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\x12%\n" +
+	"\x0eschema_version\x18\x03 \x01(\x04R\rschemaVersion\"Y\n" +
+	"\x19PauseFileActivityResponse\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\"Y\n" +
+	"\x19ResumeFileActivityRequest\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\"Z\n" +
+	"\x1aResumeFileActivityResponse\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\"P\n" +
+	"\x10ListFilesRequest\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\"p\n" +
+	"\x11ListFilesResponse\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\x12\x1d\n" +
+	"\n" +
+	"file_names\x18\x03 \x03(\tR\tfileNames\"s\n" +
+	"\x16GetFileMetadataRequest\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\x12\x1b\n" +
+	"\tfile_name\x18\x03 \x01(\tR\bfileName\"\x93\x01\n" +
+	"\fFileMetadata\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\x12\x1b\n" +
+	"\tfile_name\x18\x03 \x01(\tR\bfileName\x12\x12\n" +
+	"\x04size\x18\x04 \x01(\x03R\x04size\x12\x14\n" +
+	"\x05crc32\x18\x05 \x01(\rR\x05crc32\"\xab\x01\n" +
+	"\x0eGetFileRequest\x12\x1d\n" +
+	"\n" +
+	"index_name\x18\x01 \x01(\tR\tindexName\x12\x1d\n" +
+	"\n" +
+	"shard_name\x18\x02 \x01(\tR\tshardName\x12\x1b\n" +
+	"\tfile_name\x18\x03 \x01(\tR\bfileName\x12>\n" +
+	"\vcompression\x18\x04 \x01(\x0e2\x1c.weaviate.v1.CompressionTypeR\vcompression\"I\n" +
+	"\tFileChunk\x12\x16\n" +
+	"\x06offset\x18\x01 \x01(\x03R\x06offset\x12\x12\n" +
+	"\x04data\x18\x02 \x01(\fR\x04data\x12\x10\n" +
+	"\x03eof\x18\x03 \x01(\bR\x03eof*\x87\x01\n" +
+	"\x0fCompressionType\x12 \n" +
+	"\x1cCOMPRESSION_TYPE_UNSPECIFIED\x10\x00\x12\x19\n" +
+	"\x15COMPRESSION_TYPE_GZIP\x10\x01\x12\x19\n" +
+	"\x15COMPRESSION_TYPE_ZLIB\x10\x02\x12\x1c\n" +
+	"\x18COMPRESSION_TYPE_DEFLATE\x10\x032\xca\x03\n" +
+	"\x16FileReplicationService\x12b\n" +
+	"\x11PauseFileActivity\x12%.weaviate.v1.PauseFileActivityRequest\x1a&.weaviate.v1.PauseFileActivityResponse\x12e\n" +
+	"\x12ResumeFileActivity\x12&.weaviate.v1.ResumeFileActivityRequest\x1a'.weaviate.v1.ResumeFileActivityResponse\x12J\n" +
+	"\tListFiles\x12\x1d.weaviate.v1.ListFilesRequest\x1a\x1e.weaviate.v1.ListFilesResponse\x12U\n" +
+	"\x0fGetFileMetadata\x12#.weaviate.v1.GetFileMetadataRequest\x1a\x19.weaviate.v1.FileMetadata(\x010\x01\x12B\n" +
+	"\aGetFile\x12\x1b.weaviate.v1.GetFileRequest\x1a\x16.weaviate.v1.FileChunk(\x010\x01Bj\n" +
+	"#io.weaviate.client.grpc.protocol.v1B\rWeaviateProtoZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v1_file_replication_proto_rawDescOnce sync.Once
+	file_v1_file_replication_proto_rawDescData []byte
+)
+
+func file_v1_file_replication_proto_rawDescGZIP() []byte {
+	file_v1_file_replication_proto_rawDescOnce.Do(func() {
+		file_v1_file_replication_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_file_replication_proto_rawDesc), len(file_v1_file_replication_proto_rawDesc)))
+	})
+	return file_v1_file_replication_proto_rawDescData
+}
+
+var file_v1_file_replication_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_v1_file_replication_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
+var file_v1_file_replication_proto_goTypes = []any{
+	(CompressionType)(0),               // 0: weaviate.v1.CompressionType
+	(*PauseFileActivityRequest)(nil),   // 1: weaviate.v1.PauseFileActivityRequest
+	(*PauseFileActivityResponse)(nil),  // 2: weaviate.v1.PauseFileActivityResponse
+	(*ResumeFileActivityRequest)(nil),  // 3: weaviate.v1.ResumeFileActivityRequest
+	(*ResumeFileActivityResponse)(nil), // 4: weaviate.v1.ResumeFileActivityResponse
+	(*ListFilesRequest)(nil),           // 5: weaviate.v1.ListFilesRequest
+	(*ListFilesResponse)(nil),          // 6: weaviate.v1.ListFilesResponse
+	(*GetFileMetadataRequest)(nil),     // 7: weaviate.v1.GetFileMetadataRequest
+	(*FileMetadata)(nil),               // 8: weaviate.v1.FileMetadata
+	(*GetFileRequest)(nil),             // 9: weaviate.v1.GetFileRequest
+	(*FileChunk)(nil),                  // 10: weaviate.v1.FileChunk
+}
+var file_v1_file_replication_proto_depIdxs = []int32{
+	0,  // 0: weaviate.v1.GetFileRequest.compression:type_name -> weaviate.v1.CompressionType
+	1,  // 1: weaviate.v1.FileReplicationService.PauseFileActivity:input_type -> weaviate.v1.PauseFileActivityRequest
+	3,  // 2: weaviate.v1.FileReplicationService.ResumeFileActivity:input_type -> weaviate.v1.ResumeFileActivityRequest
+	5,  // 3: weaviate.v1.FileReplicationService.ListFiles:input_type -> weaviate.v1.ListFilesRequest
+	7,  // 4: weaviate.v1.FileReplicationService.GetFileMetadata:input_type -> weaviate.v1.GetFileMetadataRequest
+	9,  // 5: weaviate.v1.FileReplicationService.GetFile:input_type -> weaviate.v1.GetFileRequest
+	2,  // 6: weaviate.v1.FileReplicationService.PauseFileActivity:output_type -> weaviate.v1.PauseFileActivityResponse
+	4,  // 7: weaviate.v1.FileReplicationService.ResumeFileActivity:output_type -> weaviate.v1.ResumeFileActivityResponse
+	6,  // 8: weaviate.v1.FileReplicationService.ListFiles:output_type -> weaviate.v1.ListFilesResponse
+	8,  // 9: weaviate.v1.FileReplicationService.GetFileMetadata:output_type -> weaviate.v1.FileMetadata
+	10, // 10: weaviate.v1.FileReplicationService.GetFile:output_type -> weaviate.v1.FileChunk
+	6,  // [6:11] is the sub-list for method output_type
+	1,  // [1:6] is the sub-list for method input_type
+	1,  // [1:1] is the sub-list for extension type_name
+	1,  // [1:1] is the sub-list for extension extendee
+	0,  // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_v1_file_replication_proto_init() }
+func file_v1_file_replication_proto_init() {
+	if File_v1_file_replication_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_file_replication_proto_rawDesc), len(file_v1_file_replication_proto_rawDesc)),
+			NumEnums:      1,
+			NumMessages:   10,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_v1_file_replication_proto_goTypes,
+		DependencyIndexes: file_v1_file_replication_proto_depIdxs,
+		EnumInfos:         file_v1_file_replication_proto_enumTypes,
+		MessageInfos:      file_v1_file_replication_proto_msgTypes,
+	}.Build()
+	File_v1_file_replication_proto = out.File
+	file_v1_file_replication_proto_goTypes = nil
+	file_v1_file_replication_proto_depIdxs = nil
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/file_replication_grpc.pb.go

@@ -0,0 +1,260 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+
+package protocol
+
+import (
+	context "context"
+
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	FileReplicationService_PauseFileActivity_FullMethodName  = "/weaviate.v1.FileReplicationService/PauseFileActivity"
+	FileReplicationService_ResumeFileActivity_FullMethodName = "/weaviate.v1.FileReplicationService/ResumeFileActivity"
+	FileReplicationService_ListFiles_FullMethodName          = "/weaviate.v1.FileReplicationService/ListFiles"
+	FileReplicationService_GetFileMetadata_FullMethodName    = "/weaviate.v1.FileReplicationService/GetFileMetadata"
+	FileReplicationService_GetFile_FullMethodName            = "/weaviate.v1.FileReplicationService/GetFile"
+)
+
+// FileReplicationServiceClient is the client API for FileReplicationService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type FileReplicationServiceClient interface {
+	PauseFileActivity(ctx context.Context, in *PauseFileActivityRequest, opts ...grpc.CallOption) (*PauseFileActivityResponse, error)
+	ResumeFileActivity(ctx context.Context, in *ResumeFileActivityRequest, opts ...grpc.CallOption) (*ResumeFileActivityResponse, error)
+	ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (*ListFilesResponse, error)
+	GetFileMetadata(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[GetFileMetadataRequest, FileMetadata], error)
+	GetFile(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[GetFileRequest, FileChunk], error)
+}
+
+type fileReplicationServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewFileReplicationServiceClient(cc grpc.ClientConnInterface) FileReplicationServiceClient {
+	return &fileReplicationServiceClient{cc}
+}
+
+func (c *fileReplicationServiceClient) PauseFileActivity(ctx context.Context, in *PauseFileActivityRequest, opts ...grpc.CallOption) (*PauseFileActivityResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(PauseFileActivityResponse)
+	err := c.cc.Invoke(ctx, FileReplicationService_PauseFileActivity_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *fileReplicationServiceClient) ResumeFileActivity(ctx context.Context, in *ResumeFileActivityRequest, opts ...grpc.CallOption) (*ResumeFileActivityResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ResumeFileActivityResponse)
+	err := c.cc.Invoke(ctx, FileReplicationService_ResumeFileActivity_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *fileReplicationServiceClient) ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (*ListFilesResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ListFilesResponse)
+	err := c.cc.Invoke(ctx, FileReplicationService_ListFiles_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *fileReplicationServiceClient) GetFileMetadata(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[GetFileMetadataRequest, FileMetadata], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &FileReplicationService_ServiceDesc.Streams[0], FileReplicationService_GetFileMetadata_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[GetFileMetadataRequest, FileMetadata]{ClientStream: stream}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type FileReplicationService_GetFileMetadataClient = grpc.BidiStreamingClient[GetFileMetadataRequest, FileMetadata]
+
+func (c *fileReplicationServiceClient) GetFile(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[GetFileRequest, FileChunk], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &FileReplicationService_ServiceDesc.Streams[1], FileReplicationService_GetFile_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[GetFileRequest, FileChunk]{ClientStream: stream}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type FileReplicationService_GetFileClient = grpc.BidiStreamingClient[GetFileRequest, FileChunk]
+
+// FileReplicationServiceServer is the server API for FileReplicationService service.
+// All implementations must embed UnimplementedFileReplicationServiceServer
+// for forward compatibility.
+type FileReplicationServiceServer interface {
+	PauseFileActivity(context.Context, *PauseFileActivityRequest) (*PauseFileActivityResponse, error)
+	ResumeFileActivity(context.Context, *ResumeFileActivityRequest) (*ResumeFileActivityResponse, error)
+	ListFiles(context.Context, *ListFilesRequest) (*ListFilesResponse, error)
+	GetFileMetadata(grpc.BidiStreamingServer[GetFileMetadataRequest, FileMetadata]) error
+	GetFile(grpc.BidiStreamingServer[GetFileRequest, FileChunk]) error
+	mustEmbedUnimplementedFileReplicationServiceServer()
+}
+
+// UnimplementedFileReplicationServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedFileReplicationServiceServer struct{}
+
+func (UnimplementedFileReplicationServiceServer) PauseFileActivity(context.Context, *PauseFileActivityRequest) (*PauseFileActivityResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method PauseFileActivity not implemented")
+}
+func (UnimplementedFileReplicationServiceServer) ResumeFileActivity(context.Context, *ResumeFileActivityRequest) (*ResumeFileActivityResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ResumeFileActivity not implemented")
+}
+func (UnimplementedFileReplicationServiceServer) ListFiles(context.Context, *ListFilesRequest) (*ListFilesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListFiles not implemented")
+}
+func (UnimplementedFileReplicationServiceServer) GetFileMetadata(grpc.BidiStreamingServer[GetFileMetadataRequest, FileMetadata]) error {
+	return status.Errorf(codes.Unimplemented, "method GetFileMetadata not implemented")
+}
+func (UnimplementedFileReplicationServiceServer) GetFile(grpc.BidiStreamingServer[GetFileRequest, FileChunk]) error {
+	return status.Errorf(codes.Unimplemented, "method GetFile not implemented")
+}
+func (UnimplementedFileReplicationServiceServer) mustEmbedUnimplementedFileReplicationServiceServer() {
+}
+func (UnimplementedFileReplicationServiceServer) testEmbeddedByValue() {}
+
+// UnsafeFileReplicationServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to FileReplicationServiceServer will
+// result in compilation errors.
+type UnsafeFileReplicationServiceServer interface {
+	mustEmbedUnimplementedFileReplicationServiceServer()
+}
+
+func RegisterFileReplicationServiceServer(s grpc.ServiceRegistrar, srv FileReplicationServiceServer) {
+	// If the following call pancis, it indicates UnimplementedFileReplicationServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&FileReplicationService_ServiceDesc, srv)
+}
+
+func _FileReplicationService_PauseFileActivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PauseFileActivityRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FileReplicationServiceServer).PauseFileActivity(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: FileReplicationService_PauseFileActivity_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FileReplicationServiceServer).PauseFileActivity(ctx, req.(*PauseFileActivityRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _FileReplicationService_ResumeFileActivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ResumeFileActivityRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FileReplicationServiceServer).ResumeFileActivity(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: FileReplicationService_ResumeFileActivity_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FileReplicationServiceServer).ResumeFileActivity(ctx, req.(*ResumeFileActivityRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _FileReplicationService_ListFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListFilesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FileReplicationServiceServer).ListFiles(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: FileReplicationService_ListFiles_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FileReplicationServiceServer).ListFiles(ctx, req.(*ListFilesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _FileReplicationService_GetFileMetadata_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(FileReplicationServiceServer).GetFileMetadata(&grpc.GenericServerStream[GetFileMetadataRequest, FileMetadata]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type FileReplicationService_GetFileMetadataServer = grpc.BidiStreamingServer[GetFileMetadataRequest, FileMetadata]
+
+func _FileReplicationService_GetFile_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(FileReplicationServiceServer).GetFile(&grpc.GenericServerStream[GetFileRequest, FileChunk]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type FileReplicationService_GetFileServer = grpc.BidiStreamingServer[GetFileRequest, FileChunk]
+
+// FileReplicationService_ServiceDesc is the grpc.ServiceDesc for FileReplicationService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var FileReplicationService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "weaviate.v1.FileReplicationService",
+	HandlerType: (*FileReplicationServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "PauseFileActivity",
+			Handler:    _FileReplicationService_PauseFileActivity_Handler,
+		},
+		{
+			MethodName: "ResumeFileActivity",
+			Handler:    _FileReplicationService_ResumeFileActivity_Handler,
+		},
+		{
+			MethodName: "ListFiles",
+			Handler:    _FileReplicationService_ListFiles_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetFileMetadata",
+			Handler:       _FileReplicationService_GetFileMetadata_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "GetFile",
+			Handler:       _FileReplicationService_GetFile_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "v1/file_replication.proto",
+}

platform/dbops/binaries/weaviate-src/grpc/generated/protocol/v1/properties.pb.go

@@ -0,0 +1,1105 @@
+// 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 Properties struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Fields        map[string]*Value      `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Properties) Reset() {
+	*x = Properties{}
+	mi := &file_v1_properties_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Properties) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Properties) ProtoMessage() {}
+
+func (x *Properties) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 Properties.ProtoReflect.Descriptor instead.
+func (*Properties) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Properties) GetFields() map[string]*Value {
+	if x != nil {
+		return x.Fields
+	}
+	return nil
+}
+
+type Value struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Types that are valid to be assigned to Kind:
+	//
+	//	*Value_NumberValue
+	//	*Value_BoolValue
+	//	*Value_ObjectValue
+	//	*Value_ListValue
+	//	*Value_DateValue
+	//	*Value_UuidValue
+	//	*Value_IntValue
+	//	*Value_GeoValue
+	//	*Value_BlobValue
+	//	*Value_PhoneValue
+	//	*Value_NullValue
+	//	*Value_TextValue
+	Kind          isValue_Kind `protobuf_oneof:"kind"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Value) Reset() {
+	*x = Value{}
+	mi := &file_v1_properties_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Value) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Value) ProtoMessage() {}
+
+func (x *Value) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 Value.ProtoReflect.Descriptor instead.
+func (*Value) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Value) GetKind() isValue_Kind {
+	if x != nil {
+		return x.Kind
+	}
+	return nil
+}
+
+func (x *Value) GetNumberValue() float64 {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_NumberValue); ok {
+			return x.NumberValue
+		}
+	}
+	return 0
+}
+
+func (x *Value) GetBoolValue() bool {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_BoolValue); ok {
+			return x.BoolValue
+		}
+	}
+	return false
+}
+
+func (x *Value) GetObjectValue() *Properties {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_ObjectValue); ok {
+			return x.ObjectValue
+		}
+	}
+	return nil
+}
+
+func (x *Value) GetListValue() *ListValue {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_ListValue); ok {
+			return x.ListValue
+		}
+	}
+	return nil
+}
+
+func (x *Value) GetDateValue() string {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_DateValue); ok {
+			return x.DateValue
+		}
+	}
+	return ""
+}
+
+func (x *Value) GetUuidValue() string {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_UuidValue); ok {
+			return x.UuidValue
+		}
+	}
+	return ""
+}
+
+func (x *Value) GetIntValue() int64 {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_IntValue); ok {
+			return x.IntValue
+		}
+	}
+	return 0
+}
+
+func (x *Value) GetGeoValue() *GeoCoordinate {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_GeoValue); ok {
+			return x.GeoValue
+		}
+	}
+	return nil
+}
+
+func (x *Value) GetBlobValue() string {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_BlobValue); ok {
+			return x.BlobValue
+		}
+	}
+	return ""
+}
+
+func (x *Value) GetPhoneValue() *PhoneNumber {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_PhoneValue); ok {
+			return x.PhoneValue
+		}
+	}
+	return nil
+}
+
+func (x *Value) GetNullValue() structpb.NullValue {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_NullValue); ok {
+			return x.NullValue
+		}
+	}
+	return structpb.NullValue(0)
+}
+
+func (x *Value) GetTextValue() string {
+	if x != nil {
+		if x, ok := x.Kind.(*Value_TextValue); ok {
+			return x.TextValue
+		}
+	}
+	return ""
+}
+
+type isValue_Kind interface {
+	isValue_Kind()
+}
+
+type Value_NumberValue struct {
+	NumberValue float64 `protobuf:"fixed64,1,opt,name=number_value,json=numberValue,proto3,oneof"`
+}
+
+type Value_BoolValue struct {
+	// dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+	BoolValue bool `protobuf:"varint,3,opt,name=bool_value,json=boolValue,proto3,oneof"`
+}
+
+type Value_ObjectValue struct {
+	ObjectValue *Properties `protobuf:"bytes,4,opt,name=object_value,json=objectValue,proto3,oneof"`
+}
+
+type Value_ListValue struct {
+	ListValue *ListValue `protobuf:"bytes,5,opt,name=list_value,json=listValue,proto3,oneof"`
+}
+
+type Value_DateValue struct {
+	DateValue string `protobuf:"bytes,6,opt,name=date_value,json=dateValue,proto3,oneof"`
+}
+
+type Value_UuidValue struct {
+	UuidValue string `protobuf:"bytes,7,opt,name=uuid_value,json=uuidValue,proto3,oneof"`
+}
+
+type Value_IntValue struct {
+	IntValue int64 `protobuf:"varint,8,opt,name=int_value,json=intValue,proto3,oneof"`
+}
+
+type Value_GeoValue struct {
+	GeoValue *GeoCoordinate `protobuf:"bytes,9,opt,name=geo_value,json=geoValue,proto3,oneof"`
+}
+
+type Value_BlobValue struct {
+	BlobValue string `protobuf:"bytes,10,opt,name=blob_value,json=blobValue,proto3,oneof"`
+}
+
+type Value_PhoneValue struct {
+	PhoneValue *PhoneNumber `protobuf:"bytes,11,opt,name=phone_value,json=phoneValue,proto3,oneof"`
+}
+
+type Value_NullValue struct {
+	NullValue structpb.NullValue `protobuf:"varint,12,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
+}
+
+type Value_TextValue struct {
+	TextValue string `protobuf:"bytes,13,opt,name=text_value,json=textValue,proto3,oneof"`
+}
+
+func (*Value_NumberValue) isValue_Kind() {}
+
+func (*Value_BoolValue) isValue_Kind() {}
+
+func (*Value_ObjectValue) isValue_Kind() {}
+
+func (*Value_ListValue) isValue_Kind() {}
+
+func (*Value_DateValue) isValue_Kind() {}
+
+func (*Value_UuidValue) isValue_Kind() {}
+
+func (*Value_IntValue) isValue_Kind() {}
+
+func (*Value_GeoValue) isValue_Kind() {}
+
+func (*Value_BlobValue) isValue_Kind() {}
+
+func (*Value_PhoneValue) isValue_Kind() {}
+
+func (*Value_NullValue) isValue_Kind() {}
+
+func (*Value_TextValue) isValue_Kind() {}
+
+type ListValue struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Types that are valid to be assigned to Kind:
+	//
+	//	*ListValue_NumberValues
+	//	*ListValue_BoolValues
+	//	*ListValue_ObjectValues
+	//	*ListValue_DateValues
+	//	*ListValue_UuidValues
+	//	*ListValue_IntValues
+	//	*ListValue_TextValues
+	Kind          isListValue_Kind `protobuf_oneof:"kind"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListValue) Reset() {
+	*x = ListValue{}
+	mi := &file_v1_properties_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListValue) ProtoMessage() {}
+
+func (x *ListValue) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 ListValue.ProtoReflect.Descriptor instead.
+func (*ListValue) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ListValue) GetKind() isListValue_Kind {
+	if x != nil {
+		return x.Kind
+	}
+	return nil
+}
+
+func (x *ListValue) GetNumberValues() *NumberValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_NumberValues); ok {
+			return x.NumberValues
+		}
+	}
+	return nil
+}
+
+func (x *ListValue) GetBoolValues() *BoolValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_BoolValues); ok {
+			return x.BoolValues
+		}
+	}
+	return nil
+}
+
+func (x *ListValue) GetObjectValues() *ObjectValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_ObjectValues); ok {
+			return x.ObjectValues
+		}
+	}
+	return nil
+}
+
+func (x *ListValue) GetDateValues() *DateValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_DateValues); ok {
+			return x.DateValues
+		}
+	}
+	return nil
+}
+
+func (x *ListValue) GetUuidValues() *UuidValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_UuidValues); ok {
+			return x.UuidValues
+		}
+	}
+	return nil
+}
+
+func (x *ListValue) GetIntValues() *IntValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_IntValues); ok {
+			return x.IntValues
+		}
+	}
+	return nil
+}
+
+func (x *ListValue) GetTextValues() *TextValues {
+	if x != nil {
+		if x, ok := x.Kind.(*ListValue_TextValues); ok {
+			return x.TextValues
+		}
+	}
+	return nil
+}
+
+type isListValue_Kind interface {
+	isListValue_Kind()
+}
+
+type ListValue_NumberValues struct {
+	NumberValues *NumberValues `protobuf:"bytes,2,opt,name=number_values,json=numberValues,proto3,oneof"`
+}
+
+type ListValue_BoolValues struct {
+	BoolValues *BoolValues `protobuf:"bytes,3,opt,name=bool_values,json=boolValues,proto3,oneof"`
+}
+
+type ListValue_ObjectValues struct {
+	ObjectValues *ObjectValues `protobuf:"bytes,4,opt,name=object_values,json=objectValues,proto3,oneof"`
+}
+
+type ListValue_DateValues struct {
+	DateValues *DateValues `protobuf:"bytes,5,opt,name=date_values,json=dateValues,proto3,oneof"`
+}
+
+type ListValue_UuidValues struct {
+	UuidValues *UuidValues `protobuf:"bytes,6,opt,name=uuid_values,json=uuidValues,proto3,oneof"`
+}
+
+type ListValue_IntValues struct {
+	IntValues *IntValues `protobuf:"bytes,7,opt,name=int_values,json=intValues,proto3,oneof"`
+}
+
+type ListValue_TextValues struct {
+	TextValues *TextValues `protobuf:"bytes,8,opt,name=text_values,json=textValues,proto3,oneof"`
+}
+
+func (*ListValue_NumberValues) isListValue_Kind() {}
+
+func (*ListValue_BoolValues) isListValue_Kind() {}
+
+func (*ListValue_ObjectValues) isListValue_Kind() {}
+
+func (*ListValue_DateValues) isListValue_Kind() {}
+
+func (*ListValue_UuidValues) isListValue_Kind() {}
+
+func (*ListValue_IntValues) isListValue_Kind() {}
+
+func (*ListValue_TextValues) isListValue_Kind() {}
+
+type NumberValues struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// *
+	// The values are stored as a byte array, where each 8 bytes represent a single float64 value.
+	// The byte array is stored in little-endian order using uint64 encoding.
+	Values        []byte `protobuf:"bytes,1,opt,name=values,proto3" json:"values,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NumberValues) Reset() {
+	*x = NumberValues{}
+	mi := &file_v1_properties_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NumberValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NumberValues) ProtoMessage() {}
+
+func (x *NumberValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 NumberValues.ProtoReflect.Descriptor instead.
+func (*NumberValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *NumberValues) GetValues() []byte {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type TextValues 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 *TextValues) Reset() {
+	*x = TextValues{}
+	mi := &file_v1_properties_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TextValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TextValues) ProtoMessage() {}
+
+func (x *TextValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 TextValues.ProtoReflect.Descriptor instead.
+func (*TextValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *TextValues) GetValues() []string {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type BoolValues 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 *BoolValues) Reset() {
+	*x = BoolValues{}
+	mi := &file_v1_properties_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BoolValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BoolValues) ProtoMessage() {}
+
+func (x *BoolValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 BoolValues.ProtoReflect.Descriptor instead.
+func (*BoolValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *BoolValues) GetValues() []bool {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type ObjectValues struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Values        []*Properties          `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ObjectValues) Reset() {
+	*x = ObjectValues{}
+	mi := &file_v1_properties_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ObjectValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ObjectValues) ProtoMessage() {}
+
+func (x *ObjectValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 ObjectValues.ProtoReflect.Descriptor instead.
+func (*ObjectValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *ObjectValues) GetValues() []*Properties {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type DateValues 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 *DateValues) Reset() {
+	*x = DateValues{}
+	mi := &file_v1_properties_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *DateValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DateValues) ProtoMessage() {}
+
+func (x *DateValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 DateValues.ProtoReflect.Descriptor instead.
+func (*DateValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *DateValues) GetValues() []string {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type UuidValues 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 *UuidValues) Reset() {
+	*x = UuidValues{}
+	mi := &file_v1_properties_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UuidValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UuidValues) ProtoMessage() {}
+
+func (x *UuidValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 UuidValues.ProtoReflect.Descriptor instead.
+func (*UuidValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *UuidValues) GetValues() []string {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type IntValues struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// *
+	// The values are stored as a byte array, where each 8 bytes represent a single int64 value.
+	// The byte array is stored in little-endian order using uint64 encoding.
+	Values        []byte `protobuf:"bytes,1,opt,name=values,proto3" json:"values,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *IntValues) Reset() {
+	*x = IntValues{}
+	mi := &file_v1_properties_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *IntValues) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*IntValues) ProtoMessage() {}
+
+func (x *IntValues) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 IntValues.ProtoReflect.Descriptor instead.
+func (*IntValues) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *IntValues) GetValues() []byte {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+type GeoCoordinate struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Longitude     float32                `protobuf:"fixed32,1,opt,name=longitude,proto3" json:"longitude,omitempty"`
+	Latitude      float32                `protobuf:"fixed32,2,opt,name=latitude,proto3" json:"latitude,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GeoCoordinate) Reset() {
+	*x = GeoCoordinate{}
+	mi := &file_v1_properties_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GeoCoordinate) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeoCoordinate) ProtoMessage() {}
+
+func (x *GeoCoordinate) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 GeoCoordinate.ProtoReflect.Descriptor instead.
+func (*GeoCoordinate) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *GeoCoordinate) GetLongitude() float32 {
+	if x != nil {
+		return x.Longitude
+	}
+	return 0
+}
+
+func (x *GeoCoordinate) GetLatitude() float32 {
+	if x != nil {
+		return x.Latitude
+	}
+	return 0
+}
+
+type PhoneNumber struct {
+	state                  protoimpl.MessageState `protogen:"open.v1"`
+	CountryCode            uint64                 `protobuf:"varint,1,opt,name=country_code,json=countryCode,proto3" json:"country_code,omitempty"`
+	DefaultCountry         string                 `protobuf:"bytes,2,opt,name=default_country,json=defaultCountry,proto3" json:"default_country,omitempty"`
+	Input                  string                 `protobuf:"bytes,3,opt,name=input,proto3" json:"input,omitempty"`
+	InternationalFormatted string                 `protobuf:"bytes,4,opt,name=international_formatted,json=internationalFormatted,proto3" json:"international_formatted,omitempty"`
+	National               uint64                 `protobuf:"varint,5,opt,name=national,proto3" json:"national,omitempty"`
+	NationalFormatted      string                 `protobuf:"bytes,6,opt,name=national_formatted,json=nationalFormatted,proto3" json:"national_formatted,omitempty"`
+	Valid                  bool                   `protobuf:"varint,7,opt,name=valid,proto3" json:"valid,omitempty"`
+	unknownFields          protoimpl.UnknownFields
+	sizeCache              protoimpl.SizeCache
+}
+
+func (x *PhoneNumber) Reset() {
+	*x = PhoneNumber{}
+	mi := &file_v1_properties_proto_msgTypes[11]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *PhoneNumber) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PhoneNumber) ProtoMessage() {}
+
+func (x *PhoneNumber) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_properties_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 PhoneNumber.ProtoReflect.Descriptor instead.
+func (*PhoneNumber) Descriptor() ([]byte, []int) {
+	return file_v1_properties_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *PhoneNumber) GetCountryCode() uint64 {
+	if x != nil {
+		return x.CountryCode
+	}
+	return 0
+}
+
+func (x *PhoneNumber) GetDefaultCountry() string {
+	if x != nil {
+		return x.DefaultCountry
+	}
+	return ""
+}
+
+func (x *PhoneNumber) GetInput() string {
+	if x != nil {
+		return x.Input
+	}
+	return ""
+}
+
+func (x *PhoneNumber) GetInternationalFormatted() string {
+	if x != nil {
+		return x.InternationalFormatted
+	}
+	return ""
+}
+
+func (x *PhoneNumber) GetNational() uint64 {
+	if x != nil {
+		return x.National
+	}
+	return 0
+}
+
+func (x *PhoneNumber) GetNationalFormatted() string {
+	if x != nil {
+		return x.NationalFormatted
+	}
+	return ""
+}
+
+func (x *PhoneNumber) GetValid() bool {
+	if x != nil {
+		return x.Valid
+	}
+	return false
+}
+
+var File_v1_properties_proto protoreflect.FileDescriptor
+
+const file_v1_properties_proto_rawDesc = "" +
+	"\n" +
+	"\x13v1/properties.proto\x12\vweaviate.v1\x1a\x1cgoogle/protobuf/struct.proto\"\x98\x01\n" +
+	"\n" +
+	"Properties\x12;\n" +
+	"\x06fields\x18\x01 \x03(\v2#.weaviate.v1.Properties.FieldsEntryR\x06fields\x1aM\n" +
+	"\vFieldsEntry\x12\x10\n" +
+	"\x03key\x18\x01 \x01(\tR\x03key\x12(\n" +
+	"\x05value\x18\x02 \x01(\v2\x12.weaviate.v1.ValueR\x05value:\x028\x01\"\xa4\x04\n" +
+	"\x05Value\x12#\n" +
+	"\fnumber_value\x18\x01 \x01(\x01H\x00R\vnumberValue\x12\x1f\n" +
+	"\n" +
+	"bool_value\x18\x03 \x01(\bH\x00R\tboolValue\x12<\n" +
+	"\fobject_value\x18\x04 \x01(\v2\x17.weaviate.v1.PropertiesH\x00R\vobjectValue\x127\n" +
+	"\n" +
+	"list_value\x18\x05 \x01(\v2\x16.weaviate.v1.ListValueH\x00R\tlistValue\x12\x1f\n" +
+	"\n" +
+	"date_value\x18\x06 \x01(\tH\x00R\tdateValue\x12\x1f\n" +
+	"\n" +
+	"uuid_value\x18\a \x01(\tH\x00R\tuuidValue\x12\x1d\n" +
+	"\tint_value\x18\b \x01(\x03H\x00R\bintValue\x129\n" +
+	"\tgeo_value\x18\t \x01(\v2\x1a.weaviate.v1.GeoCoordinateH\x00R\bgeoValue\x12\x1f\n" +
+	"\n" +
+	"blob_value\x18\n" +
+	" \x01(\tH\x00R\tblobValue\x12;\n" +
+	"\vphone_value\x18\v \x01(\v2\x18.weaviate.v1.PhoneNumberH\x00R\n" +
+	"phoneValue\x12;\n" +
+	"\n" +
+	"null_value\x18\f \x01(\x0e2\x1a.google.protobuf.NullValueH\x00R\tnullValue\x12\x1f\n" +
+	"\n" +
+	"text_value\x18\r \x01(\tH\x00R\ttextValueB\x06\n" +
+	"\x04kind\"\xc6\x03\n" +
+	"\tListValue\x12@\n" +
+	"\rnumber_values\x18\x02 \x01(\v2\x19.weaviate.v1.NumberValuesH\x00R\fnumberValues\x12:\n" +
+	"\vbool_values\x18\x03 \x01(\v2\x17.weaviate.v1.BoolValuesH\x00R\n" +
+	"boolValues\x12@\n" +
+	"\robject_values\x18\x04 \x01(\v2\x19.weaviate.v1.ObjectValuesH\x00R\fobjectValues\x12:\n" +
+	"\vdate_values\x18\x05 \x01(\v2\x17.weaviate.v1.DateValuesH\x00R\n" +
+	"dateValues\x12:\n" +
+	"\vuuid_values\x18\x06 \x01(\v2\x17.weaviate.v1.UuidValuesH\x00R\n" +
+	"uuidValues\x127\n" +
+	"\n" +
+	"int_values\x18\a \x01(\v2\x16.weaviate.v1.IntValuesH\x00R\tintValues\x12:\n" +
+	"\vtext_values\x18\b \x01(\v2\x17.weaviate.v1.TextValuesH\x00R\n" +
+	"textValuesB\x06\n" +
+	"\x04kindJ\x04\b\x01\x10\x02\"&\n" +
+	"\fNumberValues\x12\x16\n" +
+	"\x06values\x18\x01 \x01(\fR\x06values\"$\n" +
+	"\n" +
+	"TextValues\x12\x16\n" +
+	"\x06values\x18\x01 \x03(\tR\x06values\"$\n" +
+	"\n" +
+	"BoolValues\x12\x16\n" +
+	"\x06values\x18\x01 \x03(\bR\x06values\"?\n" +
+	"\fObjectValues\x12/\n" +
+	"\x06values\x18\x01 \x03(\v2\x17.weaviate.v1.PropertiesR\x06values\"$\n" +
+	"\n" +
+	"DateValues\x12\x16\n" +
+	"\x06values\x18\x01 \x03(\tR\x06values\"$\n" +
+	"\n" +
+	"UuidValues\x12\x16\n" +
+	"\x06values\x18\x01 \x03(\tR\x06values\"#\n" +
+	"\tIntValues\x12\x16\n" +
+	"\x06values\x18\x01 \x01(\fR\x06values\"I\n" +
+	"\rGeoCoordinate\x12\x1c\n" +
+	"\tlongitude\x18\x01 \x01(\x02R\tlongitude\x12\x1a\n" +
+	"\blatitude\x18\x02 \x01(\x02R\blatitude\"\x89\x02\n" +
+	"\vPhoneNumber\x12!\n" +
+	"\fcountry_code\x18\x01 \x01(\x04R\vcountryCode\x12'\n" +
+	"\x0fdefault_country\x18\x02 \x01(\tR\x0edefaultCountry\x12\x14\n" +
+	"\x05input\x18\x03 \x01(\tR\x05input\x127\n" +
+	"\x17international_formatted\x18\x04 \x01(\tR\x16internationalFormatted\x12\x1a\n" +
+	"\bnational\x18\x05 \x01(\x04R\bnational\x12-\n" +
+	"\x12national_formatted\x18\x06 \x01(\tR\x11nationalFormatted\x12\x14\n" +
+	"\x05valid\x18\a \x01(\bR\x05validBt\n" +
+	"#io.weaviate.client.grpc.protocol.v1B\x17WeaviateProtoPropertiesZ4github.com/weaviate/weaviate/grpc/generated;protocolb\x06proto3"
+
+var (
+	file_v1_properties_proto_rawDescOnce sync.Once
+	file_v1_properties_proto_rawDescData []byte
+)
+
+func file_v1_properties_proto_rawDescGZIP() []byte {
+	file_v1_properties_proto_rawDescOnce.Do(func() {
+		file_v1_properties_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_properties_proto_rawDesc), len(file_v1_properties_proto_rawDesc)))
+	})
+	return file_v1_properties_proto_rawDescData
+}
+
+var file_v1_properties_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
+var file_v1_properties_proto_goTypes = []any{
+	(*Properties)(nil),      // 0: weaviate.v1.Properties
+	(*Value)(nil),           // 1: weaviate.v1.Value
+	(*ListValue)(nil),       // 2: weaviate.v1.ListValue
+	(*NumberValues)(nil),    // 3: weaviate.v1.NumberValues
+	(*TextValues)(nil),      // 4: weaviate.v1.TextValues
+	(*BoolValues)(nil),      // 5: weaviate.v1.BoolValues
+	(*ObjectValues)(nil),    // 6: weaviate.v1.ObjectValues
+	(*DateValues)(nil),      // 7: weaviate.v1.DateValues
+	(*UuidValues)(nil),      // 8: weaviate.v1.UuidValues
+	(*IntValues)(nil),       // 9: weaviate.v1.IntValues
+	(*GeoCoordinate)(nil),   // 10: weaviate.v1.GeoCoordinate
+	(*PhoneNumber)(nil),     // 11: weaviate.v1.PhoneNumber
+	nil,                     // 12: weaviate.v1.Properties.FieldsEntry
+	(structpb.NullValue)(0), // 13: google.protobuf.NullValue
+}
+var file_v1_properties_proto_depIdxs = []int32{
+	12, // 0: weaviate.v1.Properties.fields:type_name -> weaviate.v1.Properties.FieldsEntry
+	0,  // 1: weaviate.v1.Value.object_value:type_name -> weaviate.v1.Properties
+	2,  // 2: weaviate.v1.Value.list_value:type_name -> weaviate.v1.ListValue
+	10, // 3: weaviate.v1.Value.geo_value:type_name -> weaviate.v1.GeoCoordinate
+	11, // 4: weaviate.v1.Value.phone_value:type_name -> weaviate.v1.PhoneNumber
+	13, // 5: weaviate.v1.Value.null_value:type_name -> google.protobuf.NullValue
+	3,  // 6: weaviate.v1.ListValue.number_values:type_name -> weaviate.v1.NumberValues
+	5,  // 7: weaviate.v1.ListValue.bool_values:type_name -> weaviate.v1.BoolValues
+	6,  // 8: weaviate.v1.ListValue.object_values:type_name -> weaviate.v1.ObjectValues
+	7,  // 9: weaviate.v1.ListValue.date_values:type_name -> weaviate.v1.DateValues
+	8,  // 10: weaviate.v1.ListValue.uuid_values:type_name -> weaviate.v1.UuidValues
+	9,  // 11: weaviate.v1.ListValue.int_values:type_name -> weaviate.v1.IntValues
+	4,  // 12: weaviate.v1.ListValue.text_values:type_name -> weaviate.v1.TextValues
+	0,  // 13: weaviate.v1.ObjectValues.values:type_name -> weaviate.v1.Properties
+	1,  // 14: weaviate.v1.Properties.FieldsEntry.value:type_name -> weaviate.v1.Value
+	15, // [15:15] is the sub-list for method output_type
+	15, // [15:15] is the sub-list for method input_type
+	15, // [15:15] is the sub-list for extension type_name
+	15, // [15:15] is the sub-list for extension extendee
+	0,  // [0:15] is the sub-list for field type_name
+}
+
+func init() { file_v1_properties_proto_init() }
+func file_v1_properties_proto_init() {
+	if File_v1_properties_proto != nil {
+		return
+	}
+	file_v1_properties_proto_msgTypes[1].OneofWrappers = []any{
+		(*Value_NumberValue)(nil),
+		(*Value_BoolValue)(nil),
+		(*Value_ObjectValue)(nil),
+		(*Value_ListValue)(nil),
+		(*Value_DateValue)(nil),
+		(*Value_UuidValue)(nil),
+		(*Value_IntValue)(nil),
+		(*Value_GeoValue)(nil),
+		(*Value_BlobValue)(nil),
+		(*Value_PhoneValue)(nil),
+		(*Value_NullValue)(nil),
+		(*Value_TextValue)(nil),
+	}
+	file_v1_properties_proto_msgTypes[2].OneofWrappers = []any{
+		(*ListValue_NumberValues)(nil),
+		(*ListValue_BoolValues)(nil),
+		(*ListValue_ObjectValues)(nil),
+		(*ListValue_DateValues)(nil),
+		(*ListValue_UuidValues)(nil),
+		(*ListValue_IntValues)(nil),
+		(*ListValue_TextValues)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_properties_proto_rawDesc), len(file_v1_properties_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   13,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_v1_properties_proto_goTypes,
+		DependencyIndexes: file_v1_properties_proto_depIdxs,
+		MessageInfos:      file_v1_properties_proto_msgTypes,
+	}.Build()
+	File_v1_properties_proto = out.File
+	file_v1_properties_proto_goTypes = nil
+	file_v1_properties_proto_depIdxs = nil
+}