//                           _       _
// __      _____  __ ___   ___  __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
//  Copyright © 2016 - 2026 Weaviate B.V. All rights reserved.
//
//  CONTACT: hello@weaviate.io
//

// Code generated by mockery v2.53.5. DO NOT EDIT.

package dynamic

import (
	common "github.com/weaviate/weaviate/adapters/repos/db/vector/common"
	config "github.com/weaviate/weaviate/entities/schema/config"

	context "context"

	helpers "github.com/weaviate/weaviate/adapters/repos/db/helpers"

	mock "github.com/stretchr/testify/mock"
)

// MockVectorIndex is an autogenerated mock type for the VectorIndex type
type MockVectorIndex struct {
	mock.Mock
}

type MockVectorIndex_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVectorIndex) EXPECT() *MockVectorIndex_Expecter {
	return &MockVectorIndex_Expecter{mock: &_m.Mock}
}

// Add provides a mock function with given fields: ctx, id, vector
func (_m *MockVectorIndex) Add(ctx context.Context, id uint64, vector []float32) error {
	ret := _m.Called(ctx, id, vector)

	if len(ret) == 0 {
		panic("no return value specified for Add")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, []float32) error); ok {
		r0 = rf(ctx, id, vector)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
type MockVectorIndex_Add_Call struct {
	*mock.Call
}

// Add is a helper method to define mock.On call
//   - ctx context.Context
//   - id uint64
//   - vector []float32
func (_e *MockVectorIndex_Expecter) Add(ctx interface{}, id interface{}, vector interface{}) *MockVectorIndex_Add_Call {
	return &MockVectorIndex_Add_Call{Call: _e.mock.On("Add", ctx, id, vector)}
}

func (_c *MockVectorIndex_Add_Call) Run(run func(ctx context.Context, id uint64, vector []float32)) *MockVectorIndex_Add_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].([]float32))
	})
	return _c
}

func (_c *MockVectorIndex_Add_Call) Return(_a0 error) *MockVectorIndex_Add_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Add_Call) RunAndReturn(run func(context.Context, uint64, []float32) error) *MockVectorIndex_Add_Call {
	_c.Call.Return(run)
	return _c
}

// AddBatch provides a mock function with given fields: ctx, id, vector
func (_m *MockVectorIndex) AddBatch(ctx context.Context, id []uint64, vector [][]float32) error {
	ret := _m.Called(ctx, id, vector)

	if len(ret) == 0 {
		panic("no return value specified for AddBatch")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []uint64, [][]float32) error); ok {
		r0 = rf(ctx, id, vector)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_AddBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBatch'
type MockVectorIndex_AddBatch_Call struct {
	*mock.Call
}

// AddBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - id []uint64
//   - vector [][]float32
func (_e *MockVectorIndex_Expecter) AddBatch(ctx interface{}, id interface{}, vector interface{}) *MockVectorIndex_AddBatch_Call {
	return &MockVectorIndex_AddBatch_Call{Call: _e.mock.On("AddBatch", ctx, id, vector)}
}

func (_c *MockVectorIndex_AddBatch_Call) Run(run func(ctx context.Context, id []uint64, vector [][]float32)) *MockVectorIndex_AddBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]uint64), args[2].([][]float32))
	})
	return _c
}

func (_c *MockVectorIndex_AddBatch_Call) Return(_a0 error) *MockVectorIndex_AddBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_AddBatch_Call) RunAndReturn(run func(context.Context, []uint64, [][]float32) error) *MockVectorIndex_AddBatch_Call {
	_c.Call.Return(run)
	return _c
}

// Compressed provides a mock function with no fields
func (_m *MockVectorIndex) Compressed() bool {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Compressed")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// MockVectorIndex_Compressed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Compressed'
type MockVectorIndex_Compressed_Call struct {
	*mock.Call
}

// Compressed is a helper method to define mock.On call
func (_e *MockVectorIndex_Expecter) Compressed() *MockVectorIndex_Compressed_Call {
	return &MockVectorIndex_Compressed_Call{Call: _e.mock.On("Compressed")}
}

func (_c *MockVectorIndex_Compressed_Call) Run(run func()) *MockVectorIndex_Compressed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockVectorIndex_Compressed_Call) Return(_a0 bool) *MockVectorIndex_Compressed_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Compressed_Call) RunAndReturn(run func() bool) *MockVectorIndex_Compressed_Call {
	_c.Call.Return(run)
	return _c
}

// ContainsDoc provides a mock function with given fields: docID
func (_m *MockVectorIndex) ContainsDoc(docID uint64) bool {
	ret := _m.Called(docID)

	if len(ret) == 0 {
		panic("no return value specified for ContainsDoc")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(uint64) bool); ok {
		r0 = rf(docID)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// MockVectorIndex_ContainsDoc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainsDoc'
type MockVectorIndex_ContainsDoc_Call struct {
	*mock.Call
}

// ContainsDoc is a helper method to define mock.On call
//   - docID uint64
func (_e *MockVectorIndex_Expecter) ContainsDoc(docID interface{}) *MockVectorIndex_ContainsDoc_Call {
	return &MockVectorIndex_ContainsDoc_Call{Call: _e.mock.On("ContainsDoc", docID)}
}

func (_c *MockVectorIndex_ContainsDoc_Call) Run(run func(docID uint64)) *MockVectorIndex_ContainsDoc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *MockVectorIndex_ContainsDoc_Call) Return(_a0 bool) *MockVectorIndex_ContainsDoc_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_ContainsDoc_Call) RunAndReturn(run func(uint64) bool) *MockVectorIndex_ContainsDoc_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: id
func (_m *MockVectorIndex) Delete(id ...uint64) error {
	_va := make([]interface{}, len(id))
	for _i := range id {
		_va[_i] = id[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for Delete")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(...uint64) error); ok {
		r0 = rf(id...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
type MockVectorIndex_Delete_Call struct {
	*mock.Call
}

// Delete is a helper method to define mock.On call
//   - id ...uint64
func (_e *MockVectorIndex_Expecter) Delete(id ...interface{}) *MockVectorIndex_Delete_Call {
	return &MockVectorIndex_Delete_Call{Call: _e.mock.On("Delete",
		append([]interface{}{}, id...)...)}
}

func (_c *MockVectorIndex_Delete_Call) Run(run func(id ...uint64)) *MockVectorIndex_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]uint64, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(uint64)
			}
		}
		run(variadicArgs...)
	})
	return _c
}

func (_c *MockVectorIndex_Delete_Call) Return(_a0 error) *MockVectorIndex_Delete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Delete_Call) RunAndReturn(run func(...uint64) error) *MockVectorIndex_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// Drop provides a mock function with given fields: ctx, keepFiles
func (_m *MockVectorIndex) Drop(ctx context.Context, keepFiles bool) error {
	ret := _m.Called(ctx, keepFiles)

	if len(ret) == 0 {
		panic("no return value specified for Drop")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, bool) error); ok {
		r0 = rf(ctx, keepFiles)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_Drop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Drop'
type MockVectorIndex_Drop_Call struct {
	*mock.Call
}

// Drop is a helper method to define mock.On call
//   - ctx context.Context
//   - keepFiles bool
func (_e *MockVectorIndex_Expecter) Drop(ctx interface{}, keepFiles interface{}) *MockVectorIndex_Drop_Call {
	return &MockVectorIndex_Drop_Call{Call: _e.mock.On("Drop", ctx, keepFiles)}
}

func (_c *MockVectorIndex_Drop_Call) Run(run func(ctx context.Context, keepFiles bool)) *MockVectorIndex_Drop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(bool))
	})
	return _c
}

func (_c *MockVectorIndex_Drop_Call) Return(_a0 error) *MockVectorIndex_Drop_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Drop_Call) RunAndReturn(run func(context.Context, bool) error) *MockVectorIndex_Drop_Call {
	_c.Call.Return(run)
	return _c
}

// Flush provides a mock function with no fields
func (_m *MockVectorIndex) Flush() error {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Flush")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
type MockVectorIndex_Flush_Call struct {
	*mock.Call
}

// Flush is a helper method to define mock.On call
func (_e *MockVectorIndex_Expecter) Flush() *MockVectorIndex_Flush_Call {
	return &MockVectorIndex_Flush_Call{Call: _e.mock.On("Flush")}
}

func (_c *MockVectorIndex_Flush_Call) Run(run func()) *MockVectorIndex_Flush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockVectorIndex_Flush_Call) Return(_a0 error) *MockVectorIndex_Flush_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Flush_Call) RunAndReturn(run func() error) *MockVectorIndex_Flush_Call {
	_c.Call.Return(run)
	return _c
}

// Iterate provides a mock function with given fields: fn
func (_m *MockVectorIndex) Iterate(fn func(uint64) bool) {
	_m.Called(fn)
}

// MockVectorIndex_Iterate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Iterate'
type MockVectorIndex_Iterate_Call struct {
	*mock.Call
}

// Iterate is a helper method to define mock.On call
//   - fn func(uint64) bool
func (_e *MockVectorIndex_Expecter) Iterate(fn interface{}) *MockVectorIndex_Iterate_Call {
	return &MockVectorIndex_Iterate_Call{Call: _e.mock.On("Iterate", fn)}
}

func (_c *MockVectorIndex_Iterate_Call) Run(run func(fn func(uint64) bool)) *MockVectorIndex_Iterate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(uint64) bool))
	})
	return _c
}

func (_c *MockVectorIndex_Iterate_Call) Return() *MockVectorIndex_Iterate_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockVectorIndex_Iterate_Call) RunAndReturn(run func(func(uint64) bool)) *MockVectorIndex_Iterate_Call {
	_c.Run(run)
	return _c
}

// ListFiles provides a mock function with given fields: ctx, basePath
func (_m *MockVectorIndex) ListFiles(ctx context.Context, basePath string) ([]string, error) {
	ret := _m.Called(ctx, basePath)

	if len(ret) == 0 {
		panic("no return value specified for ListFiles")
	}

	var r0 []string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
		return rf(ctx, basePath)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []string); ok {
		r0 = rf(ctx, basePath)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, basePath)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockVectorIndex_ListFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFiles'
type MockVectorIndex_ListFiles_Call struct {
	*mock.Call
}

// ListFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - basePath string
func (_e *MockVectorIndex_Expecter) ListFiles(ctx interface{}, basePath interface{}) *MockVectorIndex_ListFiles_Call {
	return &MockVectorIndex_ListFiles_Call{Call: _e.mock.On("ListFiles", ctx, basePath)}
}

func (_c *MockVectorIndex_ListFiles_Call) Run(run func(ctx context.Context, basePath string)) *MockVectorIndex_ListFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockVectorIndex_ListFiles_Call) Return(_a0 []string, _a1 error) *MockVectorIndex_ListFiles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockVectorIndex_ListFiles_Call) RunAndReturn(run func(context.Context, string) ([]string, error)) *MockVectorIndex_ListFiles_Call {
	_c.Call.Return(run)
	return _c
}

// Multivector provides a mock function with no fields
func (_m *MockVectorIndex) Multivector() bool {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Multivector")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// MockVectorIndex_Multivector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Multivector'
type MockVectorIndex_Multivector_Call struct {
	*mock.Call
}

// Multivector is a helper method to define mock.On call
func (_e *MockVectorIndex_Expecter) Multivector() *MockVectorIndex_Multivector_Call {
	return &MockVectorIndex_Multivector_Call{Call: _e.mock.On("Multivector")}
}

func (_c *MockVectorIndex_Multivector_Call) Run(run func()) *MockVectorIndex_Multivector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockVectorIndex_Multivector_Call) Return(_a0 bool) *MockVectorIndex_Multivector_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Multivector_Call) RunAndReturn(run func() bool) *MockVectorIndex_Multivector_Call {
	_c.Call.Return(run)
	return _c
}

// PostStartup provides a mock function with given fields: ctx
func (_m *MockVectorIndex) PostStartup(ctx context.Context) {
	_m.Called(ctx)
}

// MockVectorIndex_PostStartup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostStartup'
type MockVectorIndex_PostStartup_Call struct {
	*mock.Call
}

// PostStartup is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockVectorIndex_Expecter) PostStartup(ctx interface{}) *MockVectorIndex_PostStartup_Call {
	return &MockVectorIndex_PostStartup_Call{Call: _e.mock.On("PostStartup", ctx)}
}

func (_c *MockVectorIndex_PostStartup_Call) Run(run func(ctx context.Context)) *MockVectorIndex_PostStartup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockVectorIndex_PostStartup_Call) Return() *MockVectorIndex_PostStartup_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockVectorIndex_PostStartup_Call) RunAndReturn(run func(context.Context)) *MockVectorIndex_PostStartup_Call {
	_c.Run(run)
	return _c
}

// Preload provides a mock function with given fields: id, vector
func (_m *MockVectorIndex) Preload(id uint64, vector []float32) {
	_m.Called(id, vector)
}

// MockVectorIndex_Preload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Preload'
type MockVectorIndex_Preload_Call struct {
	*mock.Call
}

// Preload is a helper method to define mock.On call
//   - id uint64
//   - vector []float32
func (_e *MockVectorIndex_Expecter) Preload(id interface{}, vector interface{}) *MockVectorIndex_Preload_Call {
	return &MockVectorIndex_Preload_Call{Call: _e.mock.On("Preload", id, vector)}
}

func (_c *MockVectorIndex_Preload_Call) Run(run func(id uint64, vector []float32)) *MockVectorIndex_Preload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64), args[1].([]float32))
	})
	return _c
}

func (_c *MockVectorIndex_Preload_Call) Return() *MockVectorIndex_Preload_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockVectorIndex_Preload_Call) RunAndReturn(run func(uint64, []float32)) *MockVectorIndex_Preload_Call {
	_c.Run(run)
	return _c
}

// QueryVectorDistancer provides a mock function with given fields: queryVector
func (_m *MockVectorIndex) QueryVectorDistancer(queryVector []float32) common.QueryVectorDistancer {
	ret := _m.Called(queryVector)

	if len(ret) == 0 {
		panic("no return value specified for QueryVectorDistancer")
	}

	var r0 common.QueryVectorDistancer
	if rf, ok := ret.Get(0).(func([]float32) common.QueryVectorDistancer); ok {
		r0 = rf(queryVector)
	} else {
		r0 = ret.Get(0).(common.QueryVectorDistancer)
	}

	return r0
}

// MockVectorIndex_QueryVectorDistancer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryVectorDistancer'
type MockVectorIndex_QueryVectorDistancer_Call struct {
	*mock.Call
}

// QueryVectorDistancer is a helper method to define mock.On call
//   - queryVector []float32
func (_e *MockVectorIndex_Expecter) QueryVectorDistancer(queryVector interface{}) *MockVectorIndex_QueryVectorDistancer_Call {
	return &MockVectorIndex_QueryVectorDistancer_Call{Call: _e.mock.On("QueryVectorDistancer", queryVector)}
}

func (_c *MockVectorIndex_QueryVectorDistancer_Call) Run(run func(queryVector []float32)) *MockVectorIndex_QueryVectorDistancer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]float32))
	})
	return _c
}

func (_c *MockVectorIndex_QueryVectorDistancer_Call) Return(_a0 common.QueryVectorDistancer) *MockVectorIndex_QueryVectorDistancer_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_QueryVectorDistancer_Call) RunAndReturn(run func([]float32) common.QueryVectorDistancer) *MockVectorIndex_QueryVectorDistancer_Call {
	_c.Call.Return(run)
	return _c
}

// SearchByVector provides a mock function with given fields: ctx, vector, k, allow
func (_m *MockVectorIndex) SearchByVector(ctx context.Context, vector []float32, k int, allow helpers.AllowList) ([]uint64, []float32, error) {
	ret := _m.Called(ctx, vector, k, allow)

	if len(ret) == 0 {
		panic("no return value specified for SearchByVector")
	}

	var r0 []uint64
	var r1 []float32
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, []float32, int, helpers.AllowList) ([]uint64, []float32, error)); ok {
		return rf(ctx, vector, k, allow)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []float32, int, helpers.AllowList) []uint64); ok {
		r0 = rf(ctx, vector, k, allow)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]uint64)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []float32, int, helpers.AllowList) []float32); ok {
		r1 = rf(ctx, vector, k, allow)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]float32)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, []float32, int, helpers.AllowList) error); ok {
		r2 = rf(ctx, vector, k, allow)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// MockVectorIndex_SearchByVector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchByVector'
type MockVectorIndex_SearchByVector_Call struct {
	*mock.Call
}

// SearchByVector is a helper method to define mock.On call
//   - ctx context.Context
//   - vector []float32
//   - k int
//   - allow helpers.AllowList
func (_e *MockVectorIndex_Expecter) SearchByVector(ctx interface{}, vector interface{}, k interface{}, allow interface{}) *MockVectorIndex_SearchByVector_Call {
	return &MockVectorIndex_SearchByVector_Call{Call: _e.mock.On("SearchByVector", ctx, vector, k, allow)}
}

func (_c *MockVectorIndex_SearchByVector_Call) Run(run func(ctx context.Context, vector []float32, k int, allow helpers.AllowList)) *MockVectorIndex_SearchByVector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]float32), args[2].(int), args[3].(helpers.AllowList))
	})
	return _c
}

func (_c *MockVectorIndex_SearchByVector_Call) Return(_a0 []uint64, _a1 []float32, _a2 error) *MockVectorIndex_SearchByVector_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockVectorIndex_SearchByVector_Call) RunAndReturn(run func(context.Context, []float32, int, helpers.AllowList) ([]uint64, []float32, error)) *MockVectorIndex_SearchByVector_Call {
	_c.Call.Return(run)
	return _c
}

// SearchByVectorDistance provides a mock function with given fields: ctx, vector, dist, maxLimit, allow
func (_m *MockVectorIndex) SearchByVectorDistance(ctx context.Context, vector []float32, dist float32, maxLimit int64, allow helpers.AllowList) ([]uint64, []float32, error) {
	ret := _m.Called(ctx, vector, dist, maxLimit, allow)

	if len(ret) == 0 {
		panic("no return value specified for SearchByVectorDistance")
	}

	var r0 []uint64
	var r1 []float32
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, []float32, float32, int64, helpers.AllowList) ([]uint64, []float32, error)); ok {
		return rf(ctx, vector, dist, maxLimit, allow)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []float32, float32, int64, helpers.AllowList) []uint64); ok {
		r0 = rf(ctx, vector, dist, maxLimit, allow)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]uint64)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []float32, float32, int64, helpers.AllowList) []float32); ok {
		r1 = rf(ctx, vector, dist, maxLimit, allow)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]float32)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, []float32, float32, int64, helpers.AllowList) error); ok {
		r2 = rf(ctx, vector, dist, maxLimit, allow)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// MockVectorIndex_SearchByVectorDistance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchByVectorDistance'
type MockVectorIndex_SearchByVectorDistance_Call struct {
	*mock.Call
}

// SearchByVectorDistance is a helper method to define mock.On call
//   - ctx context.Context
//   - vector []float32
//   - dist float32
//   - maxLimit int64
//   - allow helpers.AllowList
func (_e *MockVectorIndex_Expecter) SearchByVectorDistance(ctx interface{}, vector interface{}, dist interface{}, maxLimit interface{}, allow interface{}) *MockVectorIndex_SearchByVectorDistance_Call {
	return &MockVectorIndex_SearchByVectorDistance_Call{Call: _e.mock.On("SearchByVectorDistance", ctx, vector, dist, maxLimit, allow)}
}

func (_c *MockVectorIndex_SearchByVectorDistance_Call) Run(run func(ctx context.Context, vector []float32, dist float32, maxLimit int64, allow helpers.AllowList)) *MockVectorIndex_SearchByVectorDistance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]float32), args[2].(float32), args[3].(int64), args[4].(helpers.AllowList))
	})
	return _c
}

func (_c *MockVectorIndex_SearchByVectorDistance_Call) Return(_a0 []uint64, _a1 []float32, _a2 error) *MockVectorIndex_SearchByVectorDistance_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockVectorIndex_SearchByVectorDistance_Call) RunAndReturn(run func(context.Context, []float32, float32, int64, helpers.AllowList) ([]uint64, []float32, error)) *MockVectorIndex_SearchByVectorDistance_Call {
	_c.Call.Return(run)
	return _c
}

// Shutdown provides a mock function with given fields: ctx
func (_m *MockVectorIndex) Shutdown(ctx context.Context) error {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Shutdown")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
type MockVectorIndex_Shutdown_Call struct {
	*mock.Call
}

// Shutdown is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockVectorIndex_Expecter) Shutdown(ctx interface{}) *MockVectorIndex_Shutdown_Call {
	return &MockVectorIndex_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)}
}

func (_c *MockVectorIndex_Shutdown_Call) Run(run func(ctx context.Context)) *MockVectorIndex_Shutdown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockVectorIndex_Shutdown_Call) Return(_a0 error) *MockVectorIndex_Shutdown_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Shutdown_Call) RunAndReturn(run func(context.Context) error) *MockVectorIndex_Shutdown_Call {
	_c.Call.Return(run)
	return _c
}

// SwitchCommitLogs provides a mock function with given fields: ctx
func (_m *MockVectorIndex) SwitchCommitLogs(ctx context.Context) error {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for SwitchCommitLogs")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_SwitchCommitLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwitchCommitLogs'
type MockVectorIndex_SwitchCommitLogs_Call struct {
	*mock.Call
}

// SwitchCommitLogs is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockVectorIndex_Expecter) SwitchCommitLogs(ctx interface{}) *MockVectorIndex_SwitchCommitLogs_Call {
	return &MockVectorIndex_SwitchCommitLogs_Call{Call: _e.mock.On("SwitchCommitLogs", ctx)}
}

func (_c *MockVectorIndex_SwitchCommitLogs_Call) Run(run func(ctx context.Context)) *MockVectorIndex_SwitchCommitLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockVectorIndex_SwitchCommitLogs_Call) Return(_a0 error) *MockVectorIndex_SwitchCommitLogs_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_SwitchCommitLogs_Call) RunAndReturn(run func(context.Context) error) *MockVectorIndex_SwitchCommitLogs_Call {
	_c.Call.Return(run)
	return _c
}

// Type provides a mock function with no fields
func (_m *MockVectorIndex) Type() common.IndexType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Type")
	}

	var r0 common.IndexType
	if rf, ok := ret.Get(0).(func() common.IndexType); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(common.IndexType)
	}

	return r0
}

// MockVectorIndex_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type'
type MockVectorIndex_Type_Call struct {
	*mock.Call
}

// Type is a helper method to define mock.On call
func (_e *MockVectorIndex_Expecter) Type() *MockVectorIndex_Type_Call {
	return &MockVectorIndex_Type_Call{Call: _e.mock.On("Type")}
}

func (_c *MockVectorIndex_Type_Call) Run(run func()) *MockVectorIndex_Type_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockVectorIndex_Type_Call) Return(_a0 common.IndexType) *MockVectorIndex_Type_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_Type_Call) RunAndReturn(run func() common.IndexType) *MockVectorIndex_Type_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserConfig provides a mock function with given fields: updated, callback
func (_m *MockVectorIndex) UpdateUserConfig(updated config.VectorIndexConfig, callback func()) error {
	ret := _m.Called(updated, callback)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUserConfig")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(config.VectorIndexConfig, func()) error); ok {
		r0 = rf(updated, callback)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_UpdateUserConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserConfig'
type MockVectorIndex_UpdateUserConfig_Call struct {
	*mock.Call
}

// UpdateUserConfig is a helper method to define mock.On call
//   - updated config.VectorIndexConfig
//   - callback func()
func (_e *MockVectorIndex_Expecter) UpdateUserConfig(updated interface{}, callback interface{}) *MockVectorIndex_UpdateUserConfig_Call {
	return &MockVectorIndex_UpdateUserConfig_Call{Call: _e.mock.On("UpdateUserConfig", updated, callback)}
}

func (_c *MockVectorIndex_UpdateUserConfig_Call) Run(run func(updated config.VectorIndexConfig, callback func())) *MockVectorIndex_UpdateUserConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(config.VectorIndexConfig), args[1].(func()))
	})
	return _c
}

func (_c *MockVectorIndex_UpdateUserConfig_Call) Return(_a0 error) *MockVectorIndex_UpdateUserConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_UpdateUserConfig_Call) RunAndReturn(run func(config.VectorIndexConfig, func()) error) *MockVectorIndex_UpdateUserConfig_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateBeforeInsert provides a mock function with given fields: vector
func (_m *MockVectorIndex) ValidateBeforeInsert(vector []float32) error {
	ret := _m.Called(vector)

	if len(ret) == 0 {
		panic("no return value specified for ValidateBeforeInsert")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func([]float32) error); ok {
		r0 = rf(vector)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockVectorIndex_ValidateBeforeInsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateBeforeInsert'
type MockVectorIndex_ValidateBeforeInsert_Call struct {
	*mock.Call
}

// ValidateBeforeInsert is a helper method to define mock.On call
//   - vector []float32
func (_e *MockVectorIndex_Expecter) ValidateBeforeInsert(vector interface{}) *MockVectorIndex_ValidateBeforeInsert_Call {
	return &MockVectorIndex_ValidateBeforeInsert_Call{Call: _e.mock.On("ValidateBeforeInsert", vector)}
}

func (_c *MockVectorIndex_ValidateBeforeInsert_Call) Run(run func(vector []float32)) *MockVectorIndex_ValidateBeforeInsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]float32))
	})
	return _c
}

func (_c *MockVectorIndex_ValidateBeforeInsert_Call) Return(_a0 error) *MockVectorIndex_ValidateBeforeInsert_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockVectorIndex_ValidateBeforeInsert_Call) RunAndReturn(run func([]float32) error) *MockVectorIndex_ValidateBeforeInsert_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockVectorIndex creates a new instance of MockVectorIndex. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockVectorIndex(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockVectorIndex {
	mock := &MockVectorIndex{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
