//                           _       _
// __      _____  __ ___   ___  __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
//  \ 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 db

import (
	additional "github.com/weaviate/weaviate/entities/additional"
	aggregation "github.com/weaviate/weaviate/entities/aggregation"

	backup "github.com/weaviate/weaviate/entities/backup"

	config "github.com/weaviate/weaviate/entities/schema/config"

	context "context"

	dto "github.com/weaviate/weaviate/entities/dto"

	errors "github.com/weaviate/weaviate/entities/errors"

	file "github.com/weaviate/weaviate/usecases/file"

	filters "github.com/weaviate/weaviate/entities/filters"

	hashtree "github.com/weaviate/weaviate/usecases/replica/hashtree"

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

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

	io "io"

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

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

	models "github.com/weaviate/weaviate/entities/models"

	modules "github.com/weaviate/weaviate/usecases/modules"

	multi "github.com/weaviate/weaviate/entities/multi"

	objects "github.com/weaviate/weaviate/usecases/objects"

	replica "github.com/weaviate/weaviate/usecases/replica"

	schema "github.com/weaviate/weaviate/entities/schema"

	search "github.com/weaviate/weaviate/entities/search"

	searchparams "github.com/weaviate/weaviate/entities/searchparams"

	storagestate "github.com/weaviate/weaviate/entities/storagestate"

	storobj "github.com/weaviate/weaviate/entities/storobj"

	strfmt "github.com/go-openapi/strfmt"

	time "time"

	types "github.com/weaviate/weaviate/cluster/router/types"
)

// MockShardLike is an autogenerated mock type for the ShardLike type
type MockShardLike struct {
	mock.Mock
}

type MockShardLike_Expecter struct {
	mock *mock.Mock
}

func (_m *MockShardLike) EXPECT() *MockShardLike_Expecter {
	return &MockShardLike_Expecter{mock: &_m.Mock}
}

// Activity provides a mock function with no fields
func (_m *MockShardLike) Activity() (int32, int32) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() int32); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(int32)
	}

	return r0, r1
}

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

// Activity is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Activity() *MockShardLike_Activity_Call {
	return &MockShardLike_Activity_Call{Call: _e.mock.On("Activity")}
}

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

func (_c *MockShardLike_Activity_Call) Return(_a0 int32, _a1 int32) *MockShardLike_Activity_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_Activity_Call) RunAndReturn(run func() (int32, int32)) *MockShardLike_Activity_Call {
	_c.Call.Return(run)
	return _c
}

// AddReferencesBatch provides a mock function with given fields: ctx, refs
func (_m *MockShardLike) AddReferencesBatch(ctx context.Context, refs objects.BatchReferences) []error {
	ret := _m.Called(ctx, refs)

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

	var r0 []error
	if rf, ok := ret.Get(0).(func(context.Context, objects.BatchReferences) []error); ok {
		r0 = rf(ctx, refs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]error)
		}
	}

	return r0
}

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

// AddReferencesBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - refs objects.BatchReferences
func (_e *MockShardLike_Expecter) AddReferencesBatch(ctx interface{}, refs interface{}) *MockShardLike_AddReferencesBatch_Call {
	return &MockShardLike_AddReferencesBatch_Call{Call: _e.mock.On("AddReferencesBatch", ctx, refs)}
}

func (_c *MockShardLike_AddReferencesBatch_Call) Run(run func(ctx context.Context, refs objects.BatchReferences)) *MockShardLike_AddReferencesBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(objects.BatchReferences))
	})
	return _c
}

func (_c *MockShardLike_AddReferencesBatch_Call) Return(_a0 []error) *MockShardLike_AddReferencesBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_AddReferencesBatch_Call) RunAndReturn(run func(context.Context, objects.BatchReferences) []error) *MockShardLike_AddReferencesBatch_Call {
	_c.Call.Return(run)
	return _c
}

// Aggregate provides a mock function with given fields: ctx, params, _a2
func (_m *MockShardLike) Aggregate(ctx context.Context, params aggregation.Params, _a2 *modules.Provider) (*aggregation.Result, error) {
	ret := _m.Called(ctx, params, _a2)

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

	var r0 *aggregation.Result
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, aggregation.Params, *modules.Provider) (*aggregation.Result, error)); ok {
		return rf(ctx, params, _a2)
	}
	if rf, ok := ret.Get(0).(func(context.Context, aggregation.Params, *modules.Provider) *aggregation.Result); ok {
		r0 = rf(ctx, params, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*aggregation.Result)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, aggregation.Params, *modules.Provider) error); ok {
		r1 = rf(ctx, params, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Aggregate is a helper method to define mock.On call
//   - ctx context.Context
//   - params aggregation.Params
//   - _a2 *modules.Provider
func (_e *MockShardLike_Expecter) Aggregate(ctx interface{}, params interface{}, _a2 interface{}) *MockShardLike_Aggregate_Call {
	return &MockShardLike_Aggregate_Call{Call: _e.mock.On("Aggregate", ctx, params, _a2)}
}

func (_c *MockShardLike_Aggregate_Call) Run(run func(ctx context.Context, params aggregation.Params, _a2 *modules.Provider)) *MockShardLike_Aggregate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(aggregation.Params), args[2].(*modules.Provider))
	})
	return _c
}

func (_c *MockShardLike_Aggregate_Call) Return(_a0 *aggregation.Result, _a1 error) *MockShardLike_Aggregate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_Aggregate_Call) RunAndReturn(run func(context.Context, aggregation.Params, *modules.Provider) (*aggregation.Result, error)) *MockShardLike_Aggregate_Call {
	_c.Call.Return(run)
	return _c
}

// AnalyzeObject provides a mock function with given fields: _a0
func (_m *MockShardLike) AnalyzeObject(_a0 *storobj.Object) ([]inverted.Property, []inverted.NilProperty, error) {
	ret := _m.Called(_a0)

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

	var r0 []inverted.Property
	var r1 []inverted.NilProperty
	var r2 error
	if rf, ok := ret.Get(0).(func(*storobj.Object) ([]inverted.Property, []inverted.NilProperty, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*storobj.Object) []inverted.Property); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inverted.Property)
		}
	}

	if rf, ok := ret.Get(1).(func(*storobj.Object) []inverted.NilProperty); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]inverted.NilProperty)
		}
	}

	if rf, ok := ret.Get(2).(func(*storobj.Object) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// AnalyzeObject is a helper method to define mock.On call
//   - _a0 *storobj.Object
func (_e *MockShardLike_Expecter) AnalyzeObject(_a0 interface{}) *MockShardLike_AnalyzeObject_Call {
	return &MockShardLike_AnalyzeObject_Call{Call: _e.mock.On("AnalyzeObject", _a0)}
}

func (_c *MockShardLike_AnalyzeObject_Call) Run(run func(_a0 *storobj.Object)) *MockShardLike_AnalyzeObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*storobj.Object))
	})
	return _c
}

func (_c *MockShardLike_AnalyzeObject_Call) Return(_a0 []inverted.Property, _a1 []inverted.NilProperty, _a2 error) *MockShardLike_AnalyzeObject_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockShardLike_AnalyzeObject_Call) RunAndReturn(run func(*storobj.Object) ([]inverted.Property, []inverted.NilProperty, error)) *MockShardLike_AnalyzeObject_Call {
	_c.Call.Return(run)
	return _c
}

// ConvertQueue provides a mock function with given fields: targetVector
func (_m *MockShardLike) ConvertQueue(targetVector string) error {
	ret := _m.Called(targetVector)

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

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

	return r0
}

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

// ConvertQueue is a helper method to define mock.On call
//   - targetVector string
func (_e *MockShardLike_Expecter) ConvertQueue(targetVector interface{}) *MockShardLike_ConvertQueue_Call {
	return &MockShardLike_ConvertQueue_Call{Call: _e.mock.On("ConvertQueue", targetVector)}
}

func (_c *MockShardLike_ConvertQueue_Call) Run(run func(targetVector string)) *MockShardLike_ConvertQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

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

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

// Counter provides a mock function with no fields
func (_m *MockShardLike) Counter() *indexcounter.Counter {
	ret := _m.Called()

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

	var r0 *indexcounter.Counter
	if rf, ok := ret.Get(0).(func() *indexcounter.Counter); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexcounter.Counter)
		}
	}

	return r0
}

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

// Counter is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Counter() *MockShardLike_Counter_Call {
	return &MockShardLike_Counter_Call{Call: _e.mock.On("Counter")}
}

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

func (_c *MockShardLike_Counter_Call) Return(_a0 *indexcounter.Counter) *MockShardLike_Counter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_Counter_Call) RunAndReturn(run func() *indexcounter.Counter) *MockShardLike_Counter_Call {
	_c.Call.Return(run)
	return _c
}

// DebugGetDocIdLockStatus provides a mock function with no fields
func (_m *MockShardLike) DebugGetDocIdLockStatus() (bool, error) {
	ret := _m.Called()

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

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

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

	return r0, r1
}

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

// DebugGetDocIdLockStatus is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) DebugGetDocIdLockStatus() *MockShardLike_DebugGetDocIdLockStatus_Call {
	return &MockShardLike_DebugGetDocIdLockStatus_Call{Call: _e.mock.On("DebugGetDocIdLockStatus")}
}

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

func (_c *MockShardLike_DebugGetDocIdLockStatus_Call) Return(_a0 bool, _a1 error) *MockShardLike_DebugGetDocIdLockStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// DebugResetVectorIndex provides a mock function with given fields: ctx, targetVector
func (_m *MockShardLike) DebugResetVectorIndex(ctx context.Context, targetVector string) error {
	ret := _m.Called(ctx, targetVector)

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

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

	return r0
}

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

// DebugResetVectorIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - targetVector string
func (_e *MockShardLike_Expecter) DebugResetVectorIndex(ctx interface{}, targetVector interface{}) *MockShardLike_DebugResetVectorIndex_Call {
	return &MockShardLike_DebugResetVectorIndex_Call{Call: _e.mock.On("DebugResetVectorIndex", ctx, targetVector)}
}

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

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

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

// DeleteObject provides a mock function with given fields: ctx, id, deletionTime
func (_m *MockShardLike) DeleteObject(ctx context.Context, id strfmt.UUID, deletionTime time.Time) error {
	ret := _m.Called(ctx, id, deletionTime)

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

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

	return r0
}

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

// DeleteObject is a helper method to define mock.On call
//   - ctx context.Context
//   - id strfmt.UUID
//   - deletionTime time.Time
func (_e *MockShardLike_Expecter) DeleteObject(ctx interface{}, id interface{}, deletionTime interface{}) *MockShardLike_DeleteObject_Call {
	return &MockShardLike_DeleteObject_Call{Call: _e.mock.On("DeleteObject", ctx, id, deletionTime)}
}

func (_c *MockShardLike_DeleteObject_Call) Run(run func(ctx context.Context, id strfmt.UUID, deletionTime time.Time)) *MockShardLike_DeleteObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID), args[2].(time.Time))
	})
	return _c
}

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

func (_c *MockShardLike_DeleteObject_Call) RunAndReturn(run func(context.Context, strfmt.UUID, time.Time) error) *MockShardLike_DeleteObject_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteObjectBatch provides a mock function with given fields: ctx, ids, deletionTime, dryRun
func (_m *MockShardLike) DeleteObjectBatch(ctx context.Context, ids []strfmt.UUID, deletionTime time.Time, dryRun bool) objects.BatchSimpleObjects {
	ret := _m.Called(ctx, ids, deletionTime, dryRun)

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

	var r0 objects.BatchSimpleObjects
	if rf, ok := ret.Get(0).(func(context.Context, []strfmt.UUID, time.Time, bool) objects.BatchSimpleObjects); ok {
		r0 = rf(ctx, ids, deletionTime, dryRun)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(objects.BatchSimpleObjects)
		}
	}

	return r0
}

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

// DeleteObjectBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - ids []strfmt.UUID
//   - deletionTime time.Time
//   - dryRun bool
func (_e *MockShardLike_Expecter) DeleteObjectBatch(ctx interface{}, ids interface{}, deletionTime interface{}, dryRun interface{}) *MockShardLike_DeleteObjectBatch_Call {
	return &MockShardLike_DeleteObjectBatch_Call{Call: _e.mock.On("DeleteObjectBatch", ctx, ids, deletionTime, dryRun)}
}

func (_c *MockShardLike_DeleteObjectBatch_Call) Run(run func(ctx context.Context, ids []strfmt.UUID, deletionTime time.Time, dryRun bool)) *MockShardLike_DeleteObjectBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]strfmt.UUID), args[2].(time.Time), args[3].(bool))
	})
	return _c
}

func (_c *MockShardLike_DeleteObjectBatch_Call) Return(_a0 objects.BatchSimpleObjects) *MockShardLike_DeleteObjectBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_DeleteObjectBatch_Call) RunAndReturn(run func(context.Context, []strfmt.UUID, time.Time, bool) objects.BatchSimpleObjects) *MockShardLike_DeleteObjectBatch_Call {
	_c.Call.Return(run)
	return _c
}

// Dimensions provides a mock function with given fields: ctx, targetVector
func (_m *MockShardLike) Dimensions(ctx context.Context, targetVector string) (int, error) {
	ret := _m.Called(ctx, targetVector)

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

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (int, error)); ok {
		return rf(ctx, targetVector)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) int); ok {
		r0 = rf(ctx, targetVector)
	} else {
		r0 = ret.Get(0).(int)
	}

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

	return r0, r1
}

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

// Dimensions is a helper method to define mock.On call
//   - ctx context.Context
//   - targetVector string
func (_e *MockShardLike_Expecter) Dimensions(ctx interface{}, targetVector interface{}) *MockShardLike_Dimensions_Call {
	return &MockShardLike_Dimensions_Call{Call: _e.mock.On("Dimensions", ctx, targetVector)}
}

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

func (_c *MockShardLike_Dimensions_Call) Return(_a0 int, _a1 error) *MockShardLike_Dimensions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_Dimensions_Call) RunAndReturn(run func(context.Context, string) (int, error)) *MockShardLike_Dimensions_Call {
	_c.Call.Return(run)
	return _c
}

// Exists provides a mock function with given fields: ctx, id
func (_m *MockShardLike) Exists(ctx context.Context, id strfmt.UUID) (bool, error) {
	ret := _m.Called(ctx, id)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID) (bool, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID) bool); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Get(0).(bool)
	}

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

	return r0, r1
}

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

// Exists is a helper method to define mock.On call
//   - ctx context.Context
//   - id strfmt.UUID
func (_e *MockShardLike_Expecter) Exists(ctx interface{}, id interface{}) *MockShardLike_Exists_Call {
	return &MockShardLike_Exists_Call{Call: _e.mock.On("Exists", ctx, id)}
}

func (_c *MockShardLike_Exists_Call) Run(run func(ctx context.Context, id strfmt.UUID)) *MockShardLike_Exists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID))
	})
	return _c
}

func (_c *MockShardLike_Exists_Call) Return(_a0 bool, _a1 error) *MockShardLike_Exists_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// FillQueue provides a mock function with given fields: targetVector, from
func (_m *MockShardLike) FillQueue(targetVector string, from uint64) error {
	ret := _m.Called(targetVector, from)

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

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

	return r0
}

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

// FillQueue is a helper method to define mock.On call
//   - targetVector string
//   - from uint64
func (_e *MockShardLike_Expecter) FillQueue(targetVector interface{}, from interface{}) *MockShardLike_FillQueue_Call {
	return &MockShardLike_FillQueue_Call{Call: _e.mock.On("FillQueue", targetVector, from)}
}

func (_c *MockShardLike_FillQueue_Call) Run(run func(targetVector string, from uint64)) *MockShardLike_FillQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(uint64))
	})
	return _c
}

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

func (_c *MockShardLike_FillQueue_Call) RunAndReturn(run func(string, uint64) error) *MockShardLike_FillQueue_Call {
	_c.Call.Return(run)
	return _c
}

// FindUUIDs provides a mock function with given fields: ctx, _a1
func (_m *MockShardLike) FindUUIDs(ctx context.Context, _a1 *filters.LocalFilter) ([]strfmt.UUID, error) {
	ret := _m.Called(ctx, _a1)

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

	var r0 []strfmt.UUID
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *filters.LocalFilter) ([]strfmt.UUID, error)); ok {
		return rf(ctx, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *filters.LocalFilter) []strfmt.UUID); ok {
		r0 = rf(ctx, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]strfmt.UUID)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *filters.LocalFilter) error); ok {
		r1 = rf(ctx, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindUUIDs is a helper method to define mock.On call
//   - ctx context.Context
//   - _a1 *filters.LocalFilter
func (_e *MockShardLike_Expecter) FindUUIDs(ctx interface{}, _a1 interface{}) *MockShardLike_FindUUIDs_Call {
	return &MockShardLike_FindUUIDs_Call{Call: _e.mock.On("FindUUIDs", ctx, _a1)}
}

func (_c *MockShardLike_FindUUIDs_Call) Run(run func(ctx context.Context, _a1 *filters.LocalFilter)) *MockShardLike_FindUUIDs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*filters.LocalFilter))
	})
	return _c
}

func (_c *MockShardLike_FindUUIDs_Call) Return(_a0 []strfmt.UUID, _a1 error) *MockShardLike_FindUUIDs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_FindUUIDs_Call) RunAndReturn(run func(context.Context, *filters.LocalFilter) ([]strfmt.UUID, error)) *MockShardLike_FindUUIDs_Call {
	_c.Call.Return(run)
	return _c
}

// ForEachVectorIndex provides a mock function with given fields: f
func (_m *MockShardLike) ForEachVectorIndex(f func(string, VectorIndex) error) error {
	ret := _m.Called(f)

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

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

	return r0
}

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

// ForEachVectorIndex is a helper method to define mock.On call
//   - f func(string , VectorIndex) error
func (_e *MockShardLike_Expecter) ForEachVectorIndex(f interface{}) *MockShardLike_ForEachVectorIndex_Call {
	return &MockShardLike_ForEachVectorIndex_Call{Call: _e.mock.On("ForEachVectorIndex", f)}
}

func (_c *MockShardLike_ForEachVectorIndex_Call) Run(run func(f func(string, VectorIndex) error)) *MockShardLike_ForEachVectorIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(string, VectorIndex) error))
	})
	return _c
}

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

func (_c *MockShardLike_ForEachVectorIndex_Call) RunAndReturn(run func(func(string, VectorIndex) error) error) *MockShardLike_ForEachVectorIndex_Call {
	_c.Call.Return(run)
	return _c
}

// ForEachVectorQueue provides a mock function with given fields: f
func (_m *MockShardLike) ForEachVectorQueue(f func(string, *VectorIndexQueue) error) error {
	ret := _m.Called(f)

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

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

	return r0
}

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

// ForEachVectorQueue is a helper method to define mock.On call
//   - f func(string , *VectorIndexQueue) error
func (_e *MockShardLike_Expecter) ForEachVectorQueue(f interface{}) *MockShardLike_ForEachVectorQueue_Call {
	return &MockShardLike_ForEachVectorQueue_Call{Call: _e.mock.On("ForEachVectorQueue", f)}
}

func (_c *MockShardLike_ForEachVectorQueue_Call) Run(run func(f func(string, *VectorIndexQueue) error)) *MockShardLike_ForEachVectorQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(string, *VectorIndexQueue) error))
	})
	return _c
}

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

func (_c *MockShardLike_ForEachVectorQueue_Call) RunAndReturn(run func(func(string, *VectorIndexQueue) error) error) *MockShardLike_ForEachVectorQueue_Call {
	_c.Call.Return(run)
	return _c
}

// GetFile provides a mock function with given fields: ctx, relativeFilePath
func (_m *MockShardLike) GetFile(ctx context.Context, relativeFilePath string) (io.ReadCloser, error) {
	ret := _m.Called(ctx, relativeFilePath)

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

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

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

	return r0, r1
}

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

// GetFile is a helper method to define mock.On call
//   - ctx context.Context
//   - relativeFilePath string
func (_e *MockShardLike_Expecter) GetFile(ctx interface{}, relativeFilePath interface{}) *MockShardLike_GetFile_Call {
	return &MockShardLike_GetFile_Call{Call: _e.mock.On("GetFile", ctx, relativeFilePath)}
}

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

func (_c *MockShardLike_GetFile_Call) Return(_a0 io.ReadCloser, _a1 error) *MockShardLike_GetFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_GetFile_Call) RunAndReturn(run func(context.Context, string) (io.ReadCloser, error)) *MockShardLike_GetFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetFileMetadata provides a mock function with given fields: ctx, relativeFilePath
func (_m *MockShardLike) GetFileMetadata(ctx context.Context, relativeFilePath string) (file.FileMetadata, error) {
	ret := _m.Called(ctx, relativeFilePath)

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

	var r0 file.FileMetadata
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (file.FileMetadata, error)); ok {
		return rf(ctx, relativeFilePath)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) file.FileMetadata); ok {
		r0 = rf(ctx, relativeFilePath)
	} else {
		r0 = ret.Get(0).(file.FileMetadata)
	}

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

	return r0, r1
}

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

// GetFileMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - relativeFilePath string
func (_e *MockShardLike_Expecter) GetFileMetadata(ctx interface{}, relativeFilePath interface{}) *MockShardLike_GetFileMetadata_Call {
	return &MockShardLike_GetFileMetadata_Call{Call: _e.mock.On("GetFileMetadata", ctx, relativeFilePath)}
}

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

func (_c *MockShardLike_GetFileMetadata_Call) Return(_a0 file.FileMetadata, _a1 error) *MockShardLike_GetFileMetadata_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_GetFileMetadata_Call) RunAndReturn(run func(context.Context, string) (file.FileMetadata, error)) *MockShardLike_GetFileMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyLengthTracker provides a mock function with no fields
func (_m *MockShardLike) GetPropertyLengthTracker() *inverted.JsonShardMetaData {
	ret := _m.Called()

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

	var r0 *inverted.JsonShardMetaData
	if rf, ok := ret.Get(0).(func() *inverted.JsonShardMetaData); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*inverted.JsonShardMetaData)
		}
	}

	return r0
}

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

// GetPropertyLengthTracker is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) GetPropertyLengthTracker() *MockShardLike_GetPropertyLengthTracker_Call {
	return &MockShardLike_GetPropertyLengthTracker_Call{Call: _e.mock.On("GetPropertyLengthTracker")}
}

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

func (_c *MockShardLike_GetPropertyLengthTracker_Call) Return(_a0 *inverted.JsonShardMetaData) *MockShardLike_GetPropertyLengthTracker_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_GetPropertyLengthTracker_Call) RunAndReturn(run func() *inverted.JsonShardMetaData) *MockShardLike_GetPropertyLengthTracker_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatus provides a mock function with no fields
func (_m *MockShardLike) GetStatus() storagestate.Status {
	ret := _m.Called()

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

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

	return r0
}

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

// GetStatus is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) GetStatus() *MockShardLike_GetStatus_Call {
	return &MockShardLike_GetStatus_Call{Call: _e.mock.On("GetStatus")}
}

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

func (_c *MockShardLike_GetStatus_Call) Return(_a0 storagestate.Status) *MockShardLike_GetStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_GetStatus_Call) RunAndReturn(run func() storagestate.Status) *MockShardLike_GetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetVectorIndex provides a mock function with given fields: targetVector
func (_m *MockShardLike) GetVectorIndex(targetVector string) (VectorIndex, bool) {
	ret := _m.Called(targetVector)

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

	var r0 VectorIndex
	var r1 bool
	if rf, ok := ret.Get(0).(func(string) (VectorIndex, bool)); ok {
		return rf(targetVector)
	}
	if rf, ok := ret.Get(0).(func(string) VectorIndex); ok {
		r0 = rf(targetVector)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(VectorIndex)
		}
	}

	if rf, ok := ret.Get(1).(func(string) bool); ok {
		r1 = rf(targetVector)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

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

// GetVectorIndex is a helper method to define mock.On call
//   - targetVector string
func (_e *MockShardLike_Expecter) GetVectorIndex(targetVector interface{}) *MockShardLike_GetVectorIndex_Call {
	return &MockShardLike_GetVectorIndex_Call{Call: _e.mock.On("GetVectorIndex", targetVector)}
}

func (_c *MockShardLike_GetVectorIndex_Call) Run(run func(targetVector string)) *MockShardLike_GetVectorIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockShardLike_GetVectorIndex_Call) Return(_a0 VectorIndex, _a1 bool) *MockShardLike_GetVectorIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_GetVectorIndex_Call) RunAndReturn(run func(string) (VectorIndex, bool)) *MockShardLike_GetVectorIndex_Call {
	_c.Call.Return(run)
	return _c
}

// GetVectorIndexQueue provides a mock function with given fields: targetVector
func (_m *MockShardLike) GetVectorIndexQueue(targetVector string) (*VectorIndexQueue, bool) {
	ret := _m.Called(targetVector)

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

	var r0 *VectorIndexQueue
	var r1 bool
	if rf, ok := ret.Get(0).(func(string) (*VectorIndexQueue, bool)); ok {
		return rf(targetVector)
	}
	if rf, ok := ret.Get(0).(func(string) *VectorIndexQueue); ok {
		r0 = rf(targetVector)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*VectorIndexQueue)
		}
	}

	if rf, ok := ret.Get(1).(func(string) bool); ok {
		r1 = rf(targetVector)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

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

// GetVectorIndexQueue is a helper method to define mock.On call
//   - targetVector string
func (_e *MockShardLike_Expecter) GetVectorIndexQueue(targetVector interface{}) *MockShardLike_GetVectorIndexQueue_Call {
	return &MockShardLike_GetVectorIndexQueue_Call{Call: _e.mock.On("GetVectorIndexQueue", targetVector)}
}

func (_c *MockShardLike_GetVectorIndexQueue_Call) Run(run func(targetVector string)) *MockShardLike_GetVectorIndexQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockShardLike_GetVectorIndexQueue_Call) Return(_a0 *VectorIndexQueue, _a1 bool) *MockShardLike_GetVectorIndexQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_GetVectorIndexQueue_Call) RunAndReturn(run func(string) (*VectorIndexQueue, bool)) *MockShardLike_GetVectorIndexQueue_Call {
	_c.Call.Return(run)
	return _c
}

// HaltForTransfer provides a mock function with given fields: ctx, offloading, inactivityTimeout
func (_m *MockShardLike) HaltForTransfer(ctx context.Context, offloading bool, inactivityTimeout time.Duration) error {
	ret := _m.Called(ctx, offloading, inactivityTimeout)

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

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

	return r0
}

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

// HaltForTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - offloading bool
//   - inactivityTimeout time.Duration
func (_e *MockShardLike_Expecter) HaltForTransfer(ctx interface{}, offloading interface{}, inactivityTimeout interface{}) *MockShardLike_HaltForTransfer_Call {
	return &MockShardLike_HaltForTransfer_Call{Call: _e.mock.On("HaltForTransfer", ctx, offloading, inactivityTimeout)}
}

func (_c *MockShardLike_HaltForTransfer_Call) Run(run func(ctx context.Context, offloading bool, inactivityTimeout time.Duration)) *MockShardLike_HaltForTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(bool), args[2].(time.Duration))
	})
	return _c
}

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

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

// HashTreeLevel provides a mock function with given fields: ctx, level, discriminant
func (_m *MockShardLike) HashTreeLevel(ctx context.Context, level int, discriminant *hashtree.Bitset) ([]hashtree.Digest, error) {
	ret := _m.Called(ctx, level, discriminant)

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

	var r0 []hashtree.Digest
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int, *hashtree.Bitset) ([]hashtree.Digest, error)); ok {
		return rf(ctx, level, discriminant)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int, *hashtree.Bitset) []hashtree.Digest); ok {
		r0 = rf(ctx, level, discriminant)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]hashtree.Digest)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int, *hashtree.Bitset) error); ok {
		r1 = rf(ctx, level, discriminant)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HashTreeLevel is a helper method to define mock.On call
//   - ctx context.Context
//   - level int
//   - discriminant *hashtree.Bitset
func (_e *MockShardLike_Expecter) HashTreeLevel(ctx interface{}, level interface{}, discriminant interface{}) *MockShardLike_HashTreeLevel_Call {
	return &MockShardLike_HashTreeLevel_Call{Call: _e.mock.On("HashTreeLevel", ctx, level, discriminant)}
}

func (_c *MockShardLike_HashTreeLevel_Call) Run(run func(ctx context.Context, level int, discriminant *hashtree.Bitset)) *MockShardLike_HashTreeLevel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int), args[2].(*hashtree.Bitset))
	})
	return _c
}

func (_c *MockShardLike_HashTreeLevel_Call) Return(digests []hashtree.Digest, err error) *MockShardLike_HashTreeLevel_Call {
	_c.Call.Return(digests, err)
	return _c
}

func (_c *MockShardLike_HashTreeLevel_Call) RunAndReturn(run func(context.Context, int, *hashtree.Bitset) ([]hashtree.Digest, error)) *MockShardLike_HashTreeLevel_Call {
	_c.Call.Return(run)
	return _c
}

// ID provides a mock function with no fields
func (_m *MockShardLike) ID() string {
	ret := _m.Called()

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

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

	return r0
}

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

// ID is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) ID() *MockShardLike_ID_Call {
	return &MockShardLike_ID_Call{Call: _e.mock.On("ID")}
}

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

func (_c *MockShardLike_ID_Call) Return(_a0 string) *MockShardLike_ID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_ID_Call) RunAndReturn(run func() string) *MockShardLike_ID_Call {
	_c.Call.Return(run)
	return _c
}

// Index provides a mock function with no fields
func (_m *MockShardLike) Index() *Index {
	ret := _m.Called()

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

	var r0 *Index
	if rf, ok := ret.Get(0).(func() *Index); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Index)
		}
	}

	return r0
}

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

// Index is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Index() *MockShardLike_Index_Call {
	return &MockShardLike_Index_Call{Call: _e.mock.On("Index")}
}

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

func (_c *MockShardLike_Index_Call) Return(_a0 *Index) *MockShardLike_Index_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_Index_Call) RunAndReturn(run func() *Index) *MockShardLike_Index_Call {
	_c.Call.Return(run)
	return _c
}

// ListBackupFiles provides a mock function with given fields: ctx, ret
func (_m *MockShardLike) ListBackupFiles(ctx context.Context, ret *backup.ShardDescriptor) error {
	ret_2 := _m.Called(ctx, ret)

	if len(ret_2) == 0 {
		panic("no return value specified for ListBackupFiles")
	}

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

	return r0
}

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

// ListBackupFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - ret *backup.ShardDescriptor
func (_e *MockShardLike_Expecter) ListBackupFiles(ctx interface{}, ret interface{}) *MockShardLike_ListBackupFiles_Call {
	return &MockShardLike_ListBackupFiles_Call{Call: _e.mock.On("ListBackupFiles", ctx, ret)}
}

func (_c *MockShardLike_ListBackupFiles_Call) Run(run func(ctx context.Context, ret *backup.ShardDescriptor)) *MockShardLike_ListBackupFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*backup.ShardDescriptor))
	})
	return _c
}

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

func (_c *MockShardLike_ListBackupFiles_Call) RunAndReturn(run func(context.Context, *backup.ShardDescriptor) error) *MockShardLike_ListBackupFiles_Call {
	_c.Call.Return(run)
	return _c
}

// MergeObject provides a mock function with given fields: ctx, object
func (_m *MockShardLike) MergeObject(ctx context.Context, object objects.MergeDocument) error {
	ret := _m.Called(ctx, object)

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

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

	return r0
}

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

// MergeObject is a helper method to define mock.On call
//   - ctx context.Context
//   - object objects.MergeDocument
func (_e *MockShardLike_Expecter) MergeObject(ctx interface{}, object interface{}) *MockShardLike_MergeObject_Call {
	return &MockShardLike_MergeObject_Call{Call: _e.mock.On("MergeObject", ctx, object)}
}

func (_c *MockShardLike_MergeObject_Call) Run(run func(ctx context.Context, object objects.MergeDocument)) *MockShardLike_MergeObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(objects.MergeDocument))
	})
	return _c
}

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

func (_c *MockShardLike_MergeObject_Call) RunAndReturn(run func(context.Context, objects.MergeDocument) error) *MockShardLike_MergeObject_Call {
	_c.Call.Return(run)
	return _c
}

// Metrics provides a mock function with no fields
func (_m *MockShardLike) Metrics() *Metrics {
	ret := _m.Called()

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

	var r0 *Metrics
	if rf, ok := ret.Get(0).(func() *Metrics); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Metrics)
		}
	}

	return r0
}

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

// Metrics is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Metrics() *MockShardLike_Metrics_Call {
	return &MockShardLike_Metrics_Call{Call: _e.mock.On("Metrics")}
}

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

func (_c *MockShardLike_Metrics_Call) Return(_a0 *Metrics) *MockShardLike_Metrics_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_Metrics_Call) RunAndReturn(run func() *Metrics) *MockShardLike_Metrics_Call {
	_c.Call.Return(run)
	return _c
}

// MultiObjectByID provides a mock function with given fields: ctx, query
func (_m *MockShardLike) MultiObjectByID(ctx context.Context, query []multi.Identifier) ([]*storobj.Object, error) {
	ret := _m.Called(ctx, query)

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

	var r0 []*storobj.Object
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []multi.Identifier) ([]*storobj.Object, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []multi.Identifier) []*storobj.Object); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*storobj.Object)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []multi.Identifier) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// MultiObjectByID is a helper method to define mock.On call
//   - ctx context.Context
//   - query []multi.Identifier
func (_e *MockShardLike_Expecter) MultiObjectByID(ctx interface{}, query interface{}) *MockShardLike_MultiObjectByID_Call {
	return &MockShardLike_MultiObjectByID_Call{Call: _e.mock.On("MultiObjectByID", ctx, query)}
}

func (_c *MockShardLike_MultiObjectByID_Call) Run(run func(ctx context.Context, query []multi.Identifier)) *MockShardLike_MultiObjectByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]multi.Identifier))
	})
	return _c
}

func (_c *MockShardLike_MultiObjectByID_Call) Return(_a0 []*storobj.Object, _a1 error) *MockShardLike_MultiObjectByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_MultiObjectByID_Call) RunAndReturn(run func(context.Context, []multi.Identifier) ([]*storobj.Object, error)) *MockShardLike_MultiObjectByID_Call {
	_c.Call.Return(run)
	return _c
}

// Name provides a mock function with no fields
func (_m *MockShardLike) Name() string {
	ret := _m.Called()

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

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

	return r0
}

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

// Name is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Name() *MockShardLike_Name_Call {
	return &MockShardLike_Name_Call{Call: _e.mock.On("Name")}
}

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

func (_c *MockShardLike_Name_Call) Return(_a0 string) *MockShardLike_Name_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_Name_Call) RunAndReturn(run func() string) *MockShardLike_Name_Call {
	_c.Call.Return(run)
	return _c
}

// NotifyReady provides a mock function with no fields
func (_m *MockShardLike) NotifyReady() {
	_m.Called()
}

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

// NotifyReady is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) NotifyReady() *MockShardLike_NotifyReady_Call {
	return &MockShardLike_NotifyReady_Call{Call: _e.mock.On("NotifyReady")}
}

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

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

func (_c *MockShardLike_NotifyReady_Call) RunAndReturn(run func()) *MockShardLike_NotifyReady_Call {
	_c.Run(run)
	return _c
}

// ObjectByID provides a mock function with given fields: ctx, id, props, _a3
func (_m *MockShardLike) ObjectByID(ctx context.Context, id strfmt.UUID, props search.SelectProperties, _a3 additional.Properties) (*storobj.Object, error) {
	ret := _m.Called(ctx, id, props, _a3)

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

	var r0 *storobj.Object
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) (*storobj.Object, error)); ok {
		return rf(ctx, id, props, _a3)
	}
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) *storobj.Object); ok {
		r0 = rf(ctx, id, props, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*storobj.Object)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) error); ok {
		r1 = rf(ctx, id, props, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ObjectByID is a helper method to define mock.On call
//   - ctx context.Context
//   - id strfmt.UUID
//   - props search.SelectProperties
//   - _a3 additional.Properties
func (_e *MockShardLike_Expecter) ObjectByID(ctx interface{}, id interface{}, props interface{}, _a3 interface{}) *MockShardLike_ObjectByID_Call {
	return &MockShardLike_ObjectByID_Call{Call: _e.mock.On("ObjectByID", ctx, id, props, _a3)}
}

func (_c *MockShardLike_ObjectByID_Call) Run(run func(ctx context.Context, id strfmt.UUID, props search.SelectProperties, _a3 additional.Properties)) *MockShardLike_ObjectByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID), args[2].(search.SelectProperties), args[3].(additional.Properties))
	})
	return _c
}

func (_c *MockShardLike_ObjectByID_Call) Return(_a0 *storobj.Object, _a1 error) *MockShardLike_ObjectByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_ObjectByID_Call) RunAndReturn(run func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) (*storobj.Object, error)) *MockShardLike_ObjectByID_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectByIDErrDeleted provides a mock function with given fields: ctx, id, props, _a3
func (_m *MockShardLike) ObjectByIDErrDeleted(ctx context.Context, id strfmt.UUID, props search.SelectProperties, _a3 additional.Properties) (*storobj.Object, error) {
	ret := _m.Called(ctx, id, props, _a3)

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

	var r0 *storobj.Object
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) (*storobj.Object, error)); ok {
		return rf(ctx, id, props, _a3)
	}
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) *storobj.Object); ok {
		r0 = rf(ctx, id, props, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*storobj.Object)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) error); ok {
		r1 = rf(ctx, id, props, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ObjectByIDErrDeleted is a helper method to define mock.On call
//   - ctx context.Context
//   - id strfmt.UUID
//   - props search.SelectProperties
//   - _a3 additional.Properties
func (_e *MockShardLike_Expecter) ObjectByIDErrDeleted(ctx interface{}, id interface{}, props interface{}, _a3 interface{}) *MockShardLike_ObjectByIDErrDeleted_Call {
	return &MockShardLike_ObjectByIDErrDeleted_Call{Call: _e.mock.On("ObjectByIDErrDeleted", ctx, id, props, _a3)}
}

func (_c *MockShardLike_ObjectByIDErrDeleted_Call) Run(run func(ctx context.Context, id strfmt.UUID, props search.SelectProperties, _a3 additional.Properties)) *MockShardLike_ObjectByIDErrDeleted_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID), args[2].(search.SelectProperties), args[3].(additional.Properties))
	})
	return _c
}

func (_c *MockShardLike_ObjectByIDErrDeleted_Call) Return(_a0 *storobj.Object, _a1 error) *MockShardLike_ObjectByIDErrDeleted_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_ObjectByIDErrDeleted_Call) RunAndReturn(run func(context.Context, strfmt.UUID, search.SelectProperties, additional.Properties) (*storobj.Object, error)) *MockShardLike_ObjectByIDErrDeleted_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCount provides a mock function with given fields: ctx
func (_m *MockShardLike) ObjectCount(ctx context.Context) (int, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *MockShardLike_ObjectCount_Call) Return(_a0 int, _a1 error) *MockShardLike_ObjectCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ObjectCountAsync provides a mock function with given fields: ctx
func (_m *MockShardLike) ObjectCountAsync(ctx context.Context) (int64, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *MockShardLike_ObjectCountAsync_Call) Return(_a0 int64, _a1 error) *MockShardLike_ObjectCountAsync_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ObjectDigestsInRange provides a mock function with given fields: ctx, initialUUID, finalUUID, limit
func (_m *MockShardLike) ObjectDigestsInRange(ctx context.Context, initialUUID strfmt.UUID, finalUUID strfmt.UUID, limit int) ([]types.RepairResponse, error) {
	ret := _m.Called(ctx, initialUUID, finalUUID, limit)

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

	var r0 []types.RepairResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID, strfmt.UUID, int) ([]types.RepairResponse, error)); ok {
		return rf(ctx, initialUUID, finalUUID, limit)
	}
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID, strfmt.UUID, int) []types.RepairResponse); ok {
		r0 = rf(ctx, initialUUID, finalUUID, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.RepairResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, strfmt.UUID, strfmt.UUID, int) error); ok {
		r1 = rf(ctx, initialUUID, finalUUID, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ObjectDigestsInRange is a helper method to define mock.On call
//   - ctx context.Context
//   - initialUUID strfmt.UUID
//   - finalUUID strfmt.UUID
//   - limit int
func (_e *MockShardLike_Expecter) ObjectDigestsInRange(ctx interface{}, initialUUID interface{}, finalUUID interface{}, limit interface{}) *MockShardLike_ObjectDigestsInRange_Call {
	return &MockShardLike_ObjectDigestsInRange_Call{Call: _e.mock.On("ObjectDigestsInRange", ctx, initialUUID, finalUUID, limit)}
}

func (_c *MockShardLike_ObjectDigestsInRange_Call) Run(run func(ctx context.Context, initialUUID strfmt.UUID, finalUUID strfmt.UUID, limit int)) *MockShardLike_ObjectDigestsInRange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID), args[2].(strfmt.UUID), args[3].(int))
	})
	return _c
}

func (_c *MockShardLike_ObjectDigestsInRange_Call) Return(objs []types.RepairResponse, err error) *MockShardLike_ObjectDigestsInRange_Call {
	_c.Call.Return(objs, err)
	return _c
}

func (_c *MockShardLike_ObjectDigestsInRange_Call) RunAndReturn(run func(context.Context, strfmt.UUID, strfmt.UUID, int) ([]types.RepairResponse, error)) *MockShardLike_ObjectDigestsInRange_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectList provides a mock function with given fields: ctx, limit, sort, cursor, _a4, className
func (_m *MockShardLike) ObjectList(ctx context.Context, limit int, sort []filters.Sort, cursor *filters.Cursor, _a4 additional.Properties, className schema.ClassName) ([]*storobj.Object, error) {
	ret := _m.Called(ctx, limit, sort, cursor, _a4, className)

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

	var r0 []*storobj.Object
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int, []filters.Sort, *filters.Cursor, additional.Properties, schema.ClassName) ([]*storobj.Object, error)); ok {
		return rf(ctx, limit, sort, cursor, _a4, className)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int, []filters.Sort, *filters.Cursor, additional.Properties, schema.ClassName) []*storobj.Object); ok {
		r0 = rf(ctx, limit, sort, cursor, _a4, className)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*storobj.Object)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int, []filters.Sort, *filters.Cursor, additional.Properties, schema.ClassName) error); ok {
		r1 = rf(ctx, limit, sort, cursor, _a4, className)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ObjectList is a helper method to define mock.On call
//   - ctx context.Context
//   - limit int
//   - sort []filters.Sort
//   - cursor *filters.Cursor
//   - _a4 additional.Properties
//   - className schema.ClassName
func (_e *MockShardLike_Expecter) ObjectList(ctx interface{}, limit interface{}, sort interface{}, cursor interface{}, _a4 interface{}, className interface{}) *MockShardLike_ObjectList_Call {
	return &MockShardLike_ObjectList_Call{Call: _e.mock.On("ObjectList", ctx, limit, sort, cursor, _a4, className)}
}

func (_c *MockShardLike_ObjectList_Call) Run(run func(ctx context.Context, limit int, sort []filters.Sort, cursor *filters.Cursor, _a4 additional.Properties, className schema.ClassName)) *MockShardLike_ObjectList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int), args[2].([]filters.Sort), args[3].(*filters.Cursor), args[4].(additional.Properties), args[5].(schema.ClassName))
	})
	return _c
}

func (_c *MockShardLike_ObjectList_Call) Return(_a0 []*storobj.Object, _a1 error) *MockShardLike_ObjectList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_ObjectList_Call) RunAndReturn(run func(context.Context, int, []filters.Sort, *filters.Cursor, additional.Properties, schema.ClassName) ([]*storobj.Object, error)) *MockShardLike_ObjectList_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectSearch provides a mock function with given fields: ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties
func (_m *MockShardLike) ObjectSearch(ctx context.Context, limit int, _a2 *filters.LocalFilter, keywordRanking *searchparams.KeywordRanking, sort []filters.Sort, cursor *filters.Cursor, _a6 additional.Properties, properties []string) ([]*storobj.Object, []float32, error) {
	ret := _m.Called(ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties)

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

	var r0 []*storobj.Object
	var r1 []float32
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, int, *filters.LocalFilter, *searchparams.KeywordRanking, []filters.Sort, *filters.Cursor, additional.Properties, []string) ([]*storobj.Object, []float32, error)); ok {
		return rf(ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int, *filters.LocalFilter, *searchparams.KeywordRanking, []filters.Sort, *filters.Cursor, additional.Properties, []string) []*storobj.Object); ok {
		r0 = rf(ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*storobj.Object)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int, *filters.LocalFilter, *searchparams.KeywordRanking, []filters.Sort, *filters.Cursor, additional.Properties, []string) []float32); ok {
		r1 = rf(ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]float32)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, int, *filters.LocalFilter, *searchparams.KeywordRanking, []filters.Sort, *filters.Cursor, additional.Properties, []string) error); ok {
		r2 = rf(ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ObjectSearch is a helper method to define mock.On call
//   - ctx context.Context
//   - limit int
//   - _a2 *filters.LocalFilter
//   - keywordRanking *searchparams.KeywordRanking
//   - sort []filters.Sort
//   - cursor *filters.Cursor
//   - _a6 additional.Properties
//   - properties []string
func (_e *MockShardLike_Expecter) ObjectSearch(ctx interface{}, limit interface{}, _a2 interface{}, keywordRanking interface{}, sort interface{}, cursor interface{}, _a6 interface{}, properties interface{}) *MockShardLike_ObjectSearch_Call {
	return &MockShardLike_ObjectSearch_Call{Call: _e.mock.On("ObjectSearch", ctx, limit, _a2, keywordRanking, sort, cursor, _a6, properties)}
}

func (_c *MockShardLike_ObjectSearch_Call) Run(run func(ctx context.Context, limit int, _a2 *filters.LocalFilter, keywordRanking *searchparams.KeywordRanking, sort []filters.Sort, cursor *filters.Cursor, _a6 additional.Properties, properties []string)) *MockShardLike_ObjectSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int), args[2].(*filters.LocalFilter), args[3].(*searchparams.KeywordRanking), args[4].([]filters.Sort), args[5].(*filters.Cursor), args[6].(additional.Properties), args[7].([]string))
	})
	return _c
}

func (_c *MockShardLike_ObjectSearch_Call) Return(_a0 []*storobj.Object, _a1 []float32, _a2 error) *MockShardLike_ObjectSearch_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockShardLike_ObjectSearch_Call) RunAndReturn(run func(context.Context, int, *filters.LocalFilter, *searchparams.KeywordRanking, []filters.Sort, *filters.Cursor, additional.Properties, []string) ([]*storobj.Object, []float32, error)) *MockShardLike_ObjectSearch_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectVectorSearch provides a mock function with given fields: ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties
func (_m *MockShardLike) ObjectVectorSearch(ctx context.Context, searchVectors []models.Vector, targetVectors []string, targetDist float32, limit int, _a5 *filters.LocalFilter, sort []filters.Sort, groupBy *searchparams.GroupBy, _a8 additional.Properties, targetCombination *dto.TargetCombination, properties []string) ([]*storobj.Object, []float32, error) {
	ret := _m.Called(ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties)

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

	var r0 []*storobj.Object
	var r1 []float32
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, []models.Vector, []string, float32, int, *filters.LocalFilter, []filters.Sort, *searchparams.GroupBy, additional.Properties, *dto.TargetCombination, []string) ([]*storobj.Object, []float32, error)); ok {
		return rf(ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []models.Vector, []string, float32, int, *filters.LocalFilter, []filters.Sort, *searchparams.GroupBy, additional.Properties, *dto.TargetCombination, []string) []*storobj.Object); ok {
		r0 = rf(ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*storobj.Object)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []models.Vector, []string, float32, int, *filters.LocalFilter, []filters.Sort, *searchparams.GroupBy, additional.Properties, *dto.TargetCombination, []string) []float32); ok {
		r1 = rf(ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]float32)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, []models.Vector, []string, float32, int, *filters.LocalFilter, []filters.Sort, *searchparams.GroupBy, additional.Properties, *dto.TargetCombination, []string) error); ok {
		r2 = rf(ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ObjectVectorSearch is a helper method to define mock.On call
//   - ctx context.Context
//   - searchVectors []models.Vector
//   - targetVectors []string
//   - targetDist float32
//   - limit int
//   - _a5 *filters.LocalFilter
//   - sort []filters.Sort
//   - groupBy *searchparams.GroupBy
//   - _a8 additional.Properties
//   - targetCombination *dto.TargetCombination
//   - properties []string
func (_e *MockShardLike_Expecter) ObjectVectorSearch(ctx interface{}, searchVectors interface{}, targetVectors interface{}, targetDist interface{}, limit interface{}, _a5 interface{}, sort interface{}, groupBy interface{}, _a8 interface{}, targetCombination interface{}, properties interface{}) *MockShardLike_ObjectVectorSearch_Call {
	return &MockShardLike_ObjectVectorSearch_Call{Call: _e.mock.On("ObjectVectorSearch", ctx, searchVectors, targetVectors, targetDist, limit, _a5, sort, groupBy, _a8, targetCombination, properties)}
}

func (_c *MockShardLike_ObjectVectorSearch_Call) Run(run func(ctx context.Context, searchVectors []models.Vector, targetVectors []string, targetDist float32, limit int, _a5 *filters.LocalFilter, sort []filters.Sort, groupBy *searchparams.GroupBy, _a8 additional.Properties, targetCombination *dto.TargetCombination, properties []string)) *MockShardLike_ObjectVectorSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]models.Vector), args[2].([]string), args[3].(float32), args[4].(int), args[5].(*filters.LocalFilter), args[6].([]filters.Sort), args[7].(*searchparams.GroupBy), args[8].(additional.Properties), args[9].(*dto.TargetCombination), args[10].([]string))
	})
	return _c
}

func (_c *MockShardLike_ObjectVectorSearch_Call) Return(_a0 []*storobj.Object, _a1 []float32, _a2 error) *MockShardLike_ObjectVectorSearch_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockShardLike_ObjectVectorSearch_Call) RunAndReturn(run func(context.Context, []models.Vector, []string, float32, int, *filters.LocalFilter, []filters.Sort, *searchparams.GroupBy, additional.Properties, *dto.TargetCombination, []string) ([]*storobj.Object, []float32, error)) *MockShardLike_ObjectVectorSearch_Call {
	_c.Call.Return(run)
	return _c
}

// PutObject provides a mock function with given fields: _a0, _a1
func (_m *MockShardLike) PutObject(_a0 context.Context, _a1 *storobj.Object) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *storobj.Object) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PutObject is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *storobj.Object
func (_e *MockShardLike_Expecter) PutObject(_a0 interface{}, _a1 interface{}) *MockShardLike_PutObject_Call {
	return &MockShardLike_PutObject_Call{Call: _e.mock.On("PutObject", _a0, _a1)}
}

func (_c *MockShardLike_PutObject_Call) Run(run func(_a0 context.Context, _a1 *storobj.Object)) *MockShardLike_PutObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*storobj.Object))
	})
	return _c
}

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

func (_c *MockShardLike_PutObject_Call) RunAndReturn(run func(context.Context, *storobj.Object) error) *MockShardLike_PutObject_Call {
	_c.Call.Return(run)
	return _c
}

// PutObjectBatch provides a mock function with given fields: _a0, _a1
func (_m *MockShardLike) PutObjectBatch(_a0 context.Context, _a1 []*storobj.Object) []error {
	ret := _m.Called(_a0, _a1)

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

	var r0 []error
	if rf, ok := ret.Get(0).(func(context.Context, []*storobj.Object) []error); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]error)
		}
	}

	return r0
}

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

// PutObjectBatch is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 []*storobj.Object
func (_e *MockShardLike_Expecter) PutObjectBatch(_a0 interface{}, _a1 interface{}) *MockShardLike_PutObjectBatch_Call {
	return &MockShardLike_PutObjectBatch_Call{Call: _e.mock.On("PutObjectBatch", _a0, _a1)}
}

func (_c *MockShardLike_PutObjectBatch_Call) Run(run func(_a0 context.Context, _a1 []*storobj.Object)) *MockShardLike_PutObjectBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*storobj.Object))
	})
	return _c
}

func (_c *MockShardLike_PutObjectBatch_Call) Return(_a0 []error) *MockShardLike_PutObjectBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_PutObjectBatch_Call) RunAndReturn(run func(context.Context, []*storobj.Object) []error) *MockShardLike_PutObjectBatch_Call {
	_c.Call.Return(run)
	return _c
}

// QuantizedDimensions provides a mock function with given fields: ctx, targetVector, segments
func (_m *MockShardLike) QuantizedDimensions(ctx context.Context, targetVector string, segments int) (int, error) {
	ret := _m.Called(ctx, targetVector, segments)

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

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, int) (int, error)); ok {
		return rf(ctx, targetVector, segments)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, int) int); ok {
		r0 = rf(ctx, targetVector, segments)
	} else {
		r0 = ret.Get(0).(int)
	}

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

	return r0, r1
}

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

// QuantizedDimensions is a helper method to define mock.On call
//   - ctx context.Context
//   - targetVector string
//   - segments int
func (_e *MockShardLike_Expecter) QuantizedDimensions(ctx interface{}, targetVector interface{}, segments interface{}) *MockShardLike_QuantizedDimensions_Call {
	return &MockShardLike_QuantizedDimensions_Call{Call: _e.mock.On("QuantizedDimensions", ctx, targetVector, segments)}
}

func (_c *MockShardLike_QuantizedDimensions_Call) Run(run func(ctx context.Context, targetVector string, segments int)) *MockShardLike_QuantizedDimensions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(int))
	})
	return _c
}

func (_c *MockShardLike_QuantizedDimensions_Call) Return(_a0 int, _a1 error) *MockShardLike_QuantizedDimensions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_QuantizedDimensions_Call) RunAndReturn(run func(context.Context, string, int) (int, error)) *MockShardLike_QuantizedDimensions_Call {
	_c.Call.Return(run)
	return _c
}

// RepairIndex provides a mock function with given fields: ctx, targetVector
func (_m *MockShardLike) RepairIndex(ctx context.Context, targetVector string) error {
	ret := _m.Called(ctx, targetVector)

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

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

	return r0
}

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

// RepairIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - targetVector string
func (_e *MockShardLike_Expecter) RepairIndex(ctx interface{}, targetVector interface{}) *MockShardLike_RepairIndex_Call {
	return &MockShardLike_RepairIndex_Call{Call: _e.mock.On("RepairIndex", ctx, targetVector)}
}

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

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

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

// RequantizeIndex provides a mock function with given fields: ctx, targetVector
func (_m *MockShardLike) RequantizeIndex(ctx context.Context, targetVector string) error {
	ret := _m.Called(ctx, targetVector)

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

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

	return r0
}

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

// RequantizeIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - targetVector string
func (_e *MockShardLike_Expecter) RequantizeIndex(ctx interface{}, targetVector interface{}) *MockShardLike_RequantizeIndex_Call {
	return &MockShardLike_RequantizeIndex_Call{Call: _e.mock.On("RequantizeIndex", ctx, targetVector)}
}

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

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

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

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

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

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

	return r0
}

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

// SetAsyncReplicationEnabled is a helper method to define mock.On call
//   - ctx context.Context
//   - enabled bool
func (_e *MockShardLike_Expecter) SetAsyncReplicationEnabled(ctx interface{}, enabled interface{}) *MockShardLike_SetAsyncReplicationEnabled_Call {
	return &MockShardLike_SetAsyncReplicationEnabled_Call{Call: _e.mock.On("SetAsyncReplicationEnabled", ctx, enabled)}
}

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

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

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

// SetPropertyLengths provides a mock function with given fields: props
func (_m *MockShardLike) SetPropertyLengths(props []inverted.Property) error {
	ret := _m.Called(props)

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

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

	return r0
}

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

// SetPropertyLengths is a helper method to define mock.On call
//   - props []inverted.Property
func (_e *MockShardLike_Expecter) SetPropertyLengths(props interface{}) *MockShardLike_SetPropertyLengths_Call {
	return &MockShardLike_SetPropertyLengths_Call{Call: _e.mock.On("SetPropertyLengths", props)}
}

func (_c *MockShardLike_SetPropertyLengths_Call) Run(run func(props []inverted.Property)) *MockShardLike_SetPropertyLengths_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]inverted.Property))
	})
	return _c
}

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

func (_c *MockShardLike_SetPropertyLengths_Call) RunAndReturn(run func([]inverted.Property) error) *MockShardLike_SetPropertyLengths_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatusReadonly provides a mock function with given fields: reason
func (_m *MockShardLike) SetStatusReadonly(reason string) error {
	ret := _m.Called(reason)

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

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

	return r0
}

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

// SetStatusReadonly is a helper method to define mock.On call
//   - reason string
func (_e *MockShardLike_Expecter) SetStatusReadonly(reason interface{}) *MockShardLike_SetStatusReadonly_Call {
	return &MockShardLike_SetStatusReadonly_Call{Call: _e.mock.On("SetStatusReadonly", reason)}
}

func (_c *MockShardLike_SetStatusReadonly_Call) Run(run func(reason string)) *MockShardLike_SetStatusReadonly_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

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

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

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

	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(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

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

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

// Store provides a mock function with no fields
func (_m *MockShardLike) Store() *lsmkv.Store {
	ret := _m.Called()

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

	var r0 *lsmkv.Store
	if rf, ok := ret.Get(0).(func() *lsmkv.Store); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lsmkv.Store)
		}
	}

	return r0
}

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

// Store is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Store() *MockShardLike_Store_Call {
	return &MockShardLike_Store_Call{Call: _e.mock.On("Store")}
}

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

func (_c *MockShardLike_Store_Call) Return(_a0 *lsmkv.Store) *MockShardLike_Store_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_Store_Call) RunAndReturn(run func() *lsmkv.Store) *MockShardLike_Store_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatus provides a mock function with given fields: status, reason
func (_m *MockShardLike) UpdateStatus(status string, reason string) error {
	ret := _m.Called(status, reason)

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

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

	return r0
}

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

// UpdateStatus is a helper method to define mock.On call
//   - status string
//   - reason string
func (_e *MockShardLike_Expecter) UpdateStatus(status interface{}, reason interface{}) *MockShardLike_UpdateStatus_Call {
	return &MockShardLike_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", status, reason)}
}

func (_c *MockShardLike_UpdateStatus_Call) Run(run func(status string, reason string)) *MockShardLike_UpdateStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *MockShardLike_UpdateStatus_Call) RunAndReturn(run func(string, string) error) *MockShardLike_UpdateStatus_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateVectorIndexConfig provides a mock function with given fields: ctx, updated
func (_m *MockShardLike) UpdateVectorIndexConfig(ctx context.Context, updated config.VectorIndexConfig) error {
	ret := _m.Called(ctx, updated)

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

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

	return r0
}

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

// UpdateVectorIndexConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - updated config.VectorIndexConfig
func (_e *MockShardLike_Expecter) UpdateVectorIndexConfig(ctx interface{}, updated interface{}) *MockShardLike_UpdateVectorIndexConfig_Call {
	return &MockShardLike_UpdateVectorIndexConfig_Call{Call: _e.mock.On("UpdateVectorIndexConfig", ctx, updated)}
}

func (_c *MockShardLike_UpdateVectorIndexConfig_Call) Run(run func(ctx context.Context, updated config.VectorIndexConfig)) *MockShardLike_UpdateVectorIndexConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(config.VectorIndexConfig))
	})
	return _c
}

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

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

// UpdateVectorIndexConfigs provides a mock function with given fields: ctx, updated
func (_m *MockShardLike) UpdateVectorIndexConfigs(ctx context.Context, updated map[string]config.VectorIndexConfig) error {
	ret := _m.Called(ctx, updated)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, map[string]config.VectorIndexConfig) error); ok {
		r0 = rf(ctx, updated)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateVectorIndexConfigs is a helper method to define mock.On call
//   - ctx context.Context
//   - updated map[string]config.VectorIndexConfig
func (_e *MockShardLike_Expecter) UpdateVectorIndexConfigs(ctx interface{}, updated interface{}) *MockShardLike_UpdateVectorIndexConfigs_Call {
	return &MockShardLike_UpdateVectorIndexConfigs_Call{Call: _e.mock.On("UpdateVectorIndexConfigs", ctx, updated)}
}

func (_c *MockShardLike_UpdateVectorIndexConfigs_Call) Run(run func(ctx context.Context, updated map[string]config.VectorIndexConfig)) *MockShardLike_UpdateVectorIndexConfigs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(map[string]config.VectorIndexConfig))
	})
	return _c
}

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

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

// VectorDistanceForQuery provides a mock function with given fields: ctx, id, searchVectors, targets
func (_m *MockShardLike) VectorDistanceForQuery(ctx context.Context, id uint64, searchVectors []models.Vector, targets []string) ([]float32, error) {
	ret := _m.Called(ctx, id, searchVectors, targets)

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

	var r0 []float32
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, []models.Vector, []string) ([]float32, error)); ok {
		return rf(ctx, id, searchVectors, targets)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, []models.Vector, []string) []float32); ok {
		r0 = rf(ctx, id, searchVectors, targets)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]float32)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, []models.Vector, []string) error); ok {
		r1 = rf(ctx, id, searchVectors, targets)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// VectorDistanceForQuery is a helper method to define mock.On call
//   - ctx context.Context
//   - id uint64
//   - searchVectors []models.Vector
//   - targets []string
func (_e *MockShardLike_Expecter) VectorDistanceForQuery(ctx interface{}, id interface{}, searchVectors interface{}, targets interface{}) *MockShardLike_VectorDistanceForQuery_Call {
	return &MockShardLike_VectorDistanceForQuery_Call{Call: _e.mock.On("VectorDistanceForQuery", ctx, id, searchVectors, targets)}
}

func (_c *MockShardLike_VectorDistanceForQuery_Call) Run(run func(ctx context.Context, id uint64, searchVectors []models.Vector, targets []string)) *MockShardLike_VectorDistanceForQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].([]models.Vector), args[3].([]string))
	})
	return _c
}

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

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

// Versioner provides a mock function with no fields
func (_m *MockShardLike) Versioner() *shardVersioner {
	ret := _m.Called()

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

	var r0 *shardVersioner
	if rf, ok := ret.Get(0).(func() *shardVersioner); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shardVersioner)
		}
	}

	return r0
}

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

// Versioner is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) Versioner() *MockShardLike_Versioner_Call {
	return &MockShardLike_Versioner_Call{Call: _e.mock.On("Versioner")}
}

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

func (_c *MockShardLike_Versioner_Call) Return(_a0 *shardVersioner) *MockShardLike_Versioner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_Versioner_Call) RunAndReturn(run func() *shardVersioner) *MockShardLike_Versioner_Call {
	_c.Call.Return(run)
	return _c
}

// WasDeleted provides a mock function with given fields: ctx, id
func (_m *MockShardLike) WasDeleted(ctx context.Context, id strfmt.UUID) (bool, time.Time, error) {
	ret := _m.Called(ctx, id)

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

	var r0 bool
	var r1 time.Time
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID) (bool, time.Time, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, strfmt.UUID) bool); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, strfmt.UUID) time.Time); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Get(1).(time.Time)
	}

	if rf, ok := ret.Get(2).(func(context.Context, strfmt.UUID) error); ok {
		r2 = rf(ctx, id)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// WasDeleted is a helper method to define mock.On call
//   - ctx context.Context
//   - id strfmt.UUID
func (_e *MockShardLike_Expecter) WasDeleted(ctx interface{}, id interface{}) *MockShardLike_WasDeleted_Call {
	return &MockShardLike_WasDeleted_Call{Call: _e.mock.On("WasDeleted", ctx, id)}
}

func (_c *MockShardLike_WasDeleted_Call) Run(run func(ctx context.Context, id strfmt.UUID)) *MockShardLike_WasDeleted_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID))
	})
	return _c
}

func (_c *MockShardLike_WasDeleted_Call) Return(_a0 bool, _a1 time.Time, _a2 error) *MockShardLike_WasDeleted_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockShardLike_WasDeleted_Call) RunAndReturn(run func(context.Context, strfmt.UUID) (bool, time.Time, error)) *MockShardLike_WasDeleted_Call {
	_c.Call.Return(run)
	return _c
}

// abortReplication provides a mock function with given fields: _a0, _a1
func (_m *MockShardLike) abortReplication(_a0 context.Context, _a1 string) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// abortReplication is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
func (_e *MockShardLike_Expecter) abortReplication(_a0 interface{}, _a1 interface{}) *MockShardLike_abortReplication_Call {
	return &MockShardLike_abortReplication_Call{Call: _e.mock.On("abortReplication", _a0, _a1)}
}

func (_c *MockShardLike_abortReplication_Call) Run(run func(_a0 context.Context, _a1 string)) *MockShardLike_abortReplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockShardLike_abortReplication_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_abortReplication_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_abortReplication_Call) RunAndReturn(run func(context.Context, string) replica.SimpleResponse) *MockShardLike_abortReplication_Call {
	_c.Call.Return(run)
	return _c
}

// addJobToQueue provides a mock function with given fields: job0
func (_m *MockShardLike) addJobToQueue(job0 job) {
	_m.Called(job0)
}

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

// addJobToQueue is a helper method to define mock.On call
//   - job0 job
func (_e *MockShardLike_Expecter) addJobToQueue(job0 interface{}) *MockShardLike_addJobToQueue_Call {
	return &MockShardLike_addJobToQueue_Call{Call: _e.mock.On("addJobToQueue", job0)}
}

func (_c *MockShardLike_addJobToQueue_Call) Run(run func(job0 job)) *MockShardLike_addJobToQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(job))
	})
	return _c
}

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

func (_c *MockShardLike_addJobToQueue_Call) RunAndReturn(run func(job)) *MockShardLike_addJobToQueue_Call {
	_c.Run(run)
	return _c
}

// addTargetNodeOverride provides a mock function with given fields: ctx, targetNodeOverride
func (_m *MockShardLike) addTargetNodeOverride(ctx context.Context, targetNodeOverride additional.AsyncReplicationTargetNodeOverride) error {
	ret := _m.Called(ctx, targetNodeOverride)

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

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

	return r0
}

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

// addTargetNodeOverride is a helper method to define mock.On call
//   - ctx context.Context
//   - targetNodeOverride additional.AsyncReplicationTargetNodeOverride
func (_e *MockShardLike_Expecter) addTargetNodeOverride(ctx interface{}, targetNodeOverride interface{}) *MockShardLike_addTargetNodeOverride_Call {
	return &MockShardLike_addTargetNodeOverride_Call{Call: _e.mock.On("addTargetNodeOverride", ctx, targetNodeOverride)}
}

func (_c *MockShardLike_addTargetNodeOverride_Call) Run(run func(ctx context.Context, targetNodeOverride additional.AsyncReplicationTargetNodeOverride)) *MockShardLike_addTargetNodeOverride_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(additional.AsyncReplicationTargetNodeOverride))
	})
	return _c
}

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

func (_c *MockShardLike_addTargetNodeOverride_Call) RunAndReturn(run func(context.Context, additional.AsyncReplicationTargetNodeOverride) error) *MockShardLike_addTargetNodeOverride_Call {
	_c.Call.Return(run)
	return _c
}

// addToPropertyMapBucket provides a mock function with given fields: bucket, pair, key
func (_m *MockShardLike) addToPropertyMapBucket(bucket *lsmkv.Bucket, pair lsmkv.MapPair, key []byte) error {
	ret := _m.Called(bucket, pair, key)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*lsmkv.Bucket, lsmkv.MapPair, []byte) error); ok {
		r0 = rf(bucket, pair, key)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// addToPropertyMapBucket is a helper method to define mock.On call
//   - bucket *lsmkv.Bucket
//   - pair lsmkv.MapPair
//   - key []byte
func (_e *MockShardLike_Expecter) addToPropertyMapBucket(bucket interface{}, pair interface{}, key interface{}) *MockShardLike_addToPropertyMapBucket_Call {
	return &MockShardLike_addToPropertyMapBucket_Call{Call: _e.mock.On("addToPropertyMapBucket", bucket, pair, key)}
}

func (_c *MockShardLike_addToPropertyMapBucket_Call) Run(run func(bucket *lsmkv.Bucket, pair lsmkv.MapPair, key []byte)) *MockShardLike_addToPropertyMapBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*lsmkv.Bucket), args[1].(lsmkv.MapPair), args[2].([]byte))
	})
	return _c
}

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

func (_c *MockShardLike_addToPropertyMapBucket_Call) RunAndReturn(run func(*lsmkv.Bucket, lsmkv.MapPair, []byte) error) *MockShardLike_addToPropertyMapBucket_Call {
	_c.Call.Return(run)
	return _c
}

// addToPropertyRangeBucket provides a mock function with given fields: bucket, docID, key
func (_m *MockShardLike) addToPropertyRangeBucket(bucket *lsmkv.Bucket, docID uint64, key []byte) error {
	ret := _m.Called(bucket, docID, key)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*lsmkv.Bucket, uint64, []byte) error); ok {
		r0 = rf(bucket, docID, key)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// addToPropertyRangeBucket is a helper method to define mock.On call
//   - bucket *lsmkv.Bucket
//   - docID uint64
//   - key []byte
func (_e *MockShardLike_Expecter) addToPropertyRangeBucket(bucket interface{}, docID interface{}, key interface{}) *MockShardLike_addToPropertyRangeBucket_Call {
	return &MockShardLike_addToPropertyRangeBucket_Call{Call: _e.mock.On("addToPropertyRangeBucket", bucket, docID, key)}
}

func (_c *MockShardLike_addToPropertyRangeBucket_Call) Run(run func(bucket *lsmkv.Bucket, docID uint64, key []byte)) *MockShardLike_addToPropertyRangeBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*lsmkv.Bucket), args[1].(uint64), args[2].([]byte))
	})
	return _c
}

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

func (_c *MockShardLike_addToPropertyRangeBucket_Call) RunAndReturn(run func(*lsmkv.Bucket, uint64, []byte) error) *MockShardLike_addToPropertyRangeBucket_Call {
	_c.Call.Return(run)
	return _c
}

// addToPropertySetBucket provides a mock function with given fields: bucket, docID, key
func (_m *MockShardLike) addToPropertySetBucket(bucket *lsmkv.Bucket, docID uint64, key []byte) error {
	ret := _m.Called(bucket, docID, key)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*lsmkv.Bucket, uint64, []byte) error); ok {
		r0 = rf(bucket, docID, key)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// addToPropertySetBucket is a helper method to define mock.On call
//   - bucket *lsmkv.Bucket
//   - docID uint64
//   - key []byte
func (_e *MockShardLike_Expecter) addToPropertySetBucket(bucket interface{}, docID interface{}, key interface{}) *MockShardLike_addToPropertySetBucket_Call {
	return &MockShardLike_addToPropertySetBucket_Call{Call: _e.mock.On("addToPropertySetBucket", bucket, docID, key)}
}

func (_c *MockShardLike_addToPropertySetBucket_Call) Run(run func(bucket *lsmkv.Bucket, docID uint64, key []byte)) *MockShardLike_addToPropertySetBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*lsmkv.Bucket), args[1].(uint64), args[2].([]byte))
	})
	return _c
}

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

func (_c *MockShardLike_addToPropertySetBucket_Call) RunAndReturn(run func(*lsmkv.Bucket, uint64, []byte) error) *MockShardLike_addToPropertySetBucket_Call {
	_c.Call.Return(run)
	return _c
}

// batchDeleteObject provides a mock function with given fields: ctx, id, deletionTime
func (_m *MockShardLike) batchDeleteObject(ctx context.Context, id strfmt.UUID, deletionTime time.Time) error {
	ret := _m.Called(ctx, id, deletionTime)

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

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

	return r0
}

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

// batchDeleteObject is a helper method to define mock.On call
//   - ctx context.Context
//   - id strfmt.UUID
//   - deletionTime time.Time
func (_e *MockShardLike_Expecter) batchDeleteObject(ctx interface{}, id interface{}, deletionTime interface{}) *MockShardLike_batchDeleteObject_Call {
	return &MockShardLike_batchDeleteObject_Call{Call: _e.mock.On("batchDeleteObject", ctx, id, deletionTime)}
}

func (_c *MockShardLike_batchDeleteObject_Call) Run(run func(ctx context.Context, id strfmt.UUID, deletionTime time.Time)) *MockShardLike_batchDeleteObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(strfmt.UUID), args[2].(time.Time))
	})
	return _c
}

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

func (_c *MockShardLike_batchDeleteObject_Call) RunAndReturn(run func(context.Context, strfmt.UUID, time.Time) error) *MockShardLike_batchDeleteObject_Call {
	_c.Call.Return(run)
	return _c
}

// batchExtendInvertedIndexItemsLSMNoFrequency provides a mock function with given fields: b, item
func (_m *MockShardLike) batchExtendInvertedIndexItemsLSMNoFrequency(b *lsmkv.Bucket, item inverted.MergeItem) error {
	ret := _m.Called(b, item)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*lsmkv.Bucket, inverted.MergeItem) error); ok {
		r0 = rf(b, item)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// batchExtendInvertedIndexItemsLSMNoFrequency is a helper method to define mock.On call
//   - b *lsmkv.Bucket
//   - item inverted.MergeItem
func (_e *MockShardLike_Expecter) batchExtendInvertedIndexItemsLSMNoFrequency(b interface{}, item interface{}) *MockShardLike_batchExtendInvertedIndexItemsLSMNoFrequency_Call {
	return &MockShardLike_batchExtendInvertedIndexItemsLSMNoFrequency_Call{Call: _e.mock.On("batchExtendInvertedIndexItemsLSMNoFrequency", b, item)}
}

func (_c *MockShardLike_batchExtendInvertedIndexItemsLSMNoFrequency_Call) Run(run func(b *lsmkv.Bucket, item inverted.MergeItem)) *MockShardLike_batchExtendInvertedIndexItemsLSMNoFrequency_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*lsmkv.Bucket), args[1].(inverted.MergeItem))
	})
	return _c
}

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

func (_c *MockShardLike_batchExtendInvertedIndexItemsLSMNoFrequency_Call) RunAndReturn(run func(*lsmkv.Bucket, inverted.MergeItem) error) *MockShardLike_batchExtendInvertedIndexItemsLSMNoFrequency_Call {
	_c.Call.Return(run)
	return _c
}

// commitReplication provides a mock function with given fields: _a0, _a1
func (_m *MockShardLike) commitReplication(_a0 context.Context, _a1 string) interface{} {
	ret := _m.Called(_a0, _a1)

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

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(context.Context, string) interface{}); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	return r0
}

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

// commitReplication is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
func (_e *MockShardLike_Expecter) commitReplication(_a0 interface{}, _a1 interface{}) *MockShardLike_commitReplication_Call {
	return &MockShardLike_commitReplication_Call{Call: _e.mock.On("commitReplication", _a0, _a1)}
}

func (_c *MockShardLike_commitReplication_Call) Run(run func(_a0 context.Context, _a1 string)) *MockShardLike_commitReplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockShardLike_commitReplication_Call) Return(_a0 interface{}) *MockShardLike_commitReplication_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_commitReplication_Call) RunAndReturn(run func(context.Context, string) interface{}) *MockShardLike_commitReplication_Call {
	_c.Call.Return(run)
	return _c
}

// deleteFromPropertyRangeBucket provides a mock function with given fields: bucket, docID, key
func (_m *MockShardLike) deleteFromPropertyRangeBucket(bucket *lsmkv.Bucket, docID uint64, key []byte) error {
	ret := _m.Called(bucket, docID, key)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*lsmkv.Bucket, uint64, []byte) error); ok {
		r0 = rf(bucket, docID, key)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// deleteFromPropertyRangeBucket is a helper method to define mock.On call
//   - bucket *lsmkv.Bucket
//   - docID uint64
//   - key []byte
func (_e *MockShardLike_Expecter) deleteFromPropertyRangeBucket(bucket interface{}, docID interface{}, key interface{}) *MockShardLike_deleteFromPropertyRangeBucket_Call {
	return &MockShardLike_deleteFromPropertyRangeBucket_Call{Call: _e.mock.On("deleteFromPropertyRangeBucket", bucket, docID, key)}
}

func (_c *MockShardLike_deleteFromPropertyRangeBucket_Call) Run(run func(bucket *lsmkv.Bucket, docID uint64, key []byte)) *MockShardLike_deleteFromPropertyRangeBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*lsmkv.Bucket), args[1].(uint64), args[2].([]byte))
	})
	return _c
}

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

func (_c *MockShardLike_deleteFromPropertyRangeBucket_Call) RunAndReturn(run func(*lsmkv.Bucket, uint64, []byte) error) *MockShardLike_deleteFromPropertyRangeBucket_Call {
	_c.Call.Return(run)
	return _c
}

// deleteFromPropertySetBucket provides a mock function with given fields: bucket, docID, key
func (_m *MockShardLike) deleteFromPropertySetBucket(bucket *lsmkv.Bucket, docID uint64, key []byte) error {
	ret := _m.Called(bucket, docID, key)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*lsmkv.Bucket, uint64, []byte) error); ok {
		r0 = rf(bucket, docID, key)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// deleteFromPropertySetBucket is a helper method to define mock.On call
//   - bucket *lsmkv.Bucket
//   - docID uint64
//   - key []byte
func (_e *MockShardLike_Expecter) deleteFromPropertySetBucket(bucket interface{}, docID interface{}, key interface{}) *MockShardLike_deleteFromPropertySetBucket_Call {
	return &MockShardLike_deleteFromPropertySetBucket_Call{Call: _e.mock.On("deleteFromPropertySetBucket", bucket, docID, key)}
}

func (_c *MockShardLike_deleteFromPropertySetBucket_Call) Run(run func(bucket *lsmkv.Bucket, docID uint64, key []byte)) *MockShardLike_deleteFromPropertySetBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*lsmkv.Bucket), args[1].(uint64), args[2].([]byte))
	})
	return _c
}

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

func (_c *MockShardLike_deleteFromPropertySetBucket_Call) RunAndReturn(run func(*lsmkv.Bucket, uint64, []byte) error) *MockShardLike_deleteFromPropertySetBucket_Call {
	_c.Call.Return(run)
	return _c
}

// drop provides a mock function with given fields: keepFiles
func (_m *MockShardLike) drop(keepFiles bool) error {
	ret := _m.Called(keepFiles)

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

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

	return r0
}

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

// drop is a helper method to define mock.On call
//   - keepFiles bool
func (_e *MockShardLike_Expecter) drop(keepFiles interface{}) *MockShardLike_drop_Call {
	return &MockShardLike_drop_Call{Call: _e.mock.On("drop", keepFiles)}
}

func (_c *MockShardLike_drop_Call) Run(run func(keepFiles bool)) *MockShardLike_drop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

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

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

// extendDimensionTrackerLSM provides a mock function with given fields: dimLength, docID, targetVector
func (_m *MockShardLike) extendDimensionTrackerLSM(dimLength int, docID uint64, targetVector string) error {
	ret := _m.Called(dimLength, docID, targetVector)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(int, uint64, string) error); ok {
		r0 = rf(dimLength, docID, targetVector)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// extendDimensionTrackerLSM is a helper method to define mock.On call
//   - dimLength int
//   - docID uint64
//   - targetVector string
func (_e *MockShardLike_Expecter) extendDimensionTrackerLSM(dimLength interface{}, docID interface{}, targetVector interface{}) *MockShardLike_extendDimensionTrackerLSM_Call {
	return &MockShardLike_extendDimensionTrackerLSM_Call{Call: _e.mock.On("extendDimensionTrackerLSM", dimLength, docID, targetVector)}
}

func (_c *MockShardLike_extendDimensionTrackerLSM_Call) Run(run func(dimLength int, docID uint64, targetVector string)) *MockShardLike_extendDimensionTrackerLSM_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int), args[1].(uint64), args[2].(string))
	})
	return _c
}

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

func (_c *MockShardLike_extendDimensionTrackerLSM_Call) RunAndReturn(run func(int, uint64, string) error) *MockShardLike_extendDimensionTrackerLSM_Call {
	_c.Call.Return(run)
	return _c
}

// filePutter provides a mock function with given fields: _a0, _a1
func (_m *MockShardLike) filePutter(_a0 context.Context, _a1 string) (io.WriteCloser, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 io.WriteCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (io.WriteCloser, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) io.WriteCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.WriteCloser)
		}
	}

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

	return r0, r1
}

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

// filePutter is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
func (_e *MockShardLike_Expecter) filePutter(_a0 interface{}, _a1 interface{}) *MockShardLike_filePutter_Call {
	return &MockShardLike_filePutter_Call{Call: _e.mock.On("filePutter", _a0, _a1)}
}

func (_c *MockShardLike_filePutter_Call) Run(run func(_a0 context.Context, _a1 string)) *MockShardLike_filePutter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockShardLike_filePutter_Call) Return(_a0 io.WriteCloser, _a1 error) *MockShardLike_filePutter_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_filePutter_Call) RunAndReturn(run func(context.Context, string) (io.WriteCloser, error)) *MockShardLike_filePutter_Call {
	_c.Call.Return(run)
	return _c
}

// getAsyncReplicationStats provides a mock function with given fields: ctx
func (_m *MockShardLike) getAsyncReplicationStats(ctx context.Context) []*models.AsyncReplicationStatus {
	ret := _m.Called(ctx)

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

	var r0 []*models.AsyncReplicationStatus
	if rf, ok := ret.Get(0).(func(context.Context) []*models.AsyncReplicationStatus); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*models.AsyncReplicationStatus)
		}
	}

	return r0
}

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

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

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

func (_c *MockShardLike_getAsyncReplicationStats_Call) Return(_a0 []*models.AsyncReplicationStatus) *MockShardLike_getAsyncReplicationStats_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_getAsyncReplicationStats_Call) RunAndReturn(run func(context.Context) []*models.AsyncReplicationStatus) *MockShardLike_getAsyncReplicationStats_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// hasGeoIndex is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) hasGeoIndex() *MockShardLike_hasGeoIndex_Call {
	return &MockShardLike_hasGeoIndex_Call{Call: _e.mock.On("hasGeoIndex")}
}

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

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

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

// initPropertyBuckets provides a mock function with given fields: ctx, eg, lazyLoadSegments, props
func (_m *MockShardLike) initPropertyBuckets(ctx context.Context, eg *errors.ErrorGroupWrapper, lazyLoadSegments bool, props ...*models.Property) {
	_va := make([]interface{}, len(props))
	for _i := range props {
		_va[_i] = props[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, eg, lazyLoadSegments)
	_ca = append(_ca, _va...)
	_m.Called(_ca...)
}

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

// initPropertyBuckets is a helper method to define mock.On call
//   - ctx context.Context
//   - eg *errors.ErrorGroupWrapper
//   - lazyLoadSegments bool
//   - props ...*models.Property
func (_e *MockShardLike_Expecter) initPropertyBuckets(ctx interface{}, eg interface{}, lazyLoadSegments interface{}, props ...interface{}) *MockShardLike_initPropertyBuckets_Call {
	return &MockShardLike_initPropertyBuckets_Call{Call: _e.mock.On("initPropertyBuckets",
		append([]interface{}{ctx, eg, lazyLoadSegments}, props...)...)}
}

func (_c *MockShardLike_initPropertyBuckets_Call) Run(run func(ctx context.Context, eg *errors.ErrorGroupWrapper, lazyLoadSegments bool, props ...*models.Property)) *MockShardLike_initPropertyBuckets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*models.Property, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(*models.Property)
			}
		}
		run(args[0].(context.Context), args[1].(*errors.ErrorGroupWrapper), args[2].(bool), variadicArgs...)
	})
	return _c
}

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

func (_c *MockShardLike_initPropertyBuckets_Call) RunAndReturn(run func(context.Context, *errors.ErrorGroupWrapper, bool, ...*models.Property)) *MockShardLike_initPropertyBuckets_Call {
	_c.Run(run)
	return _c
}

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

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

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

	return r0
}

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

// isReadOnly is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) isReadOnly() *MockShardLike_isReadOnly_Call {
	return &MockShardLike_isReadOnly_Call{Call: _e.mock.On("isReadOnly")}
}

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

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

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

// mayUpsertObjectHashTree provides a mock function with given fields: object, idBytes, status
func (_m *MockShardLike) mayUpsertObjectHashTree(object *storobj.Object, idBytes []byte, status objectInsertStatus) error {
	ret := _m.Called(object, idBytes, status)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*storobj.Object, []byte, objectInsertStatus) error); ok {
		r0 = rf(object, idBytes, status)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// mayUpsertObjectHashTree is a helper method to define mock.On call
//   - object *storobj.Object
//   - idBytes []byte
//   - status objectInsertStatus
func (_e *MockShardLike_Expecter) mayUpsertObjectHashTree(object interface{}, idBytes interface{}, status interface{}) *MockShardLike_mayUpsertObjectHashTree_Call {
	return &MockShardLike_mayUpsertObjectHashTree_Call{Call: _e.mock.On("mayUpsertObjectHashTree", object, idBytes, status)}
}

func (_c *MockShardLike_mayUpsertObjectHashTree_Call) Run(run func(object *storobj.Object, idBytes []byte, status objectInsertStatus)) *MockShardLike_mayUpsertObjectHashTree_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*storobj.Object), args[1].([]byte), args[2].(objectInsertStatus))
	})
	return _c
}

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

func (_c *MockShardLike_mayUpsertObjectHashTree_Call) RunAndReturn(run func(*storobj.Object, []byte, objectInsertStatus) error) *MockShardLike_mayUpsertObjectHashTree_Call {
	_c.Call.Return(run)
	return _c
}

// mutableMergeObjectLSM provides a mock function with given fields: merge, idBytes
func (_m *MockShardLike) mutableMergeObjectLSM(merge objects.MergeDocument, idBytes []byte) (mutableMergeResult, error) {
	ret := _m.Called(merge, idBytes)

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

	var r0 mutableMergeResult
	var r1 error
	if rf, ok := ret.Get(0).(func(objects.MergeDocument, []byte) (mutableMergeResult, error)); ok {
		return rf(merge, idBytes)
	}
	if rf, ok := ret.Get(0).(func(objects.MergeDocument, []byte) mutableMergeResult); ok {
		r0 = rf(merge, idBytes)
	} else {
		r0 = ret.Get(0).(mutableMergeResult)
	}

	if rf, ok := ret.Get(1).(func(objects.MergeDocument, []byte) error); ok {
		r1 = rf(merge, idBytes)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// mutableMergeObjectLSM is a helper method to define mock.On call
//   - merge objects.MergeDocument
//   - idBytes []byte
func (_e *MockShardLike_Expecter) mutableMergeObjectLSM(merge interface{}, idBytes interface{}) *MockShardLike_mutableMergeObjectLSM_Call {
	return &MockShardLike_mutableMergeObjectLSM_Call{Call: _e.mock.On("mutableMergeObjectLSM", merge, idBytes)}
}

func (_c *MockShardLike_mutableMergeObjectLSM_Call) Run(run func(merge objects.MergeDocument, idBytes []byte)) *MockShardLike_mutableMergeObjectLSM_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(objects.MergeDocument), args[1].([]byte))
	})
	return _c
}

func (_c *MockShardLike_mutableMergeObjectLSM_Call) Return(_a0 mutableMergeResult, _a1 error) *MockShardLike_mutableMergeObjectLSM_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_mutableMergeObjectLSM_Call) RunAndReturn(run func(objects.MergeDocument, []byte) (mutableMergeResult, error)) *MockShardLike_mutableMergeObjectLSM_Call {
	_c.Call.Return(run)
	return _c
}

// pairPropertyWithFrequency provides a mock function with given fields: docID, freq, propLen
func (_m *MockShardLike) pairPropertyWithFrequency(docID uint64, freq float32, propLen float32) lsmkv.MapPair {
	ret := _m.Called(docID, freq, propLen)

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

	var r0 lsmkv.MapPair
	if rf, ok := ret.Get(0).(func(uint64, float32, float32) lsmkv.MapPair); ok {
		r0 = rf(docID, freq, propLen)
	} else {
		r0 = ret.Get(0).(lsmkv.MapPair)
	}

	return r0
}

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

// pairPropertyWithFrequency is a helper method to define mock.On call
//   - docID uint64
//   - freq float32
//   - propLen float32
func (_e *MockShardLike_Expecter) pairPropertyWithFrequency(docID interface{}, freq interface{}, propLen interface{}) *MockShardLike_pairPropertyWithFrequency_Call {
	return &MockShardLike_pairPropertyWithFrequency_Call{Call: _e.mock.On("pairPropertyWithFrequency", docID, freq, propLen)}
}

func (_c *MockShardLike_pairPropertyWithFrequency_Call) Run(run func(docID uint64, freq float32, propLen float32)) *MockShardLike_pairPropertyWithFrequency_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64), args[1].(float32), args[2].(float32))
	})
	return _c
}

func (_c *MockShardLike_pairPropertyWithFrequency_Call) Return(_a0 lsmkv.MapPair) *MockShardLike_pairPropertyWithFrequency_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_pairPropertyWithFrequency_Call) RunAndReturn(run func(uint64, float32, float32) lsmkv.MapPair) *MockShardLike_pairPropertyWithFrequency_Call {
	_c.Call.Return(run)
	return _c
}

// pathLSM provides a mock function with no fields
func (_m *MockShardLike) pathLSM() string {
	ret := _m.Called()

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

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

	return r0
}

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

// pathLSM is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) pathLSM() *MockShardLike_pathLSM_Call {
	return &MockShardLike_pathLSM_Call{Call: _e.mock.On("pathLSM")}
}

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

func (_c *MockShardLike_pathLSM_Call) Return(_a0 string) *MockShardLike_pathLSM_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_pathLSM_Call) RunAndReturn(run func() string) *MockShardLike_pathLSM_Call {
	_c.Call.Return(run)
	return _c
}

// prepareAddReferences provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockShardLike) prepareAddReferences(_a0 context.Context, _a1 string, _a2 []objects.BatchReference) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, []objects.BatchReference) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// prepareAddReferences is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
//   - _a2 []objects.BatchReference
func (_e *MockShardLike_Expecter) prepareAddReferences(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockShardLike_prepareAddReferences_Call {
	return &MockShardLike_prepareAddReferences_Call{Call: _e.mock.On("prepareAddReferences", _a0, _a1, _a2)}
}

func (_c *MockShardLike_prepareAddReferences_Call) Run(run func(_a0 context.Context, _a1 string, _a2 []objects.BatchReference)) *MockShardLike_prepareAddReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]objects.BatchReference))
	})
	return _c
}

func (_c *MockShardLike_prepareAddReferences_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_prepareAddReferences_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_prepareAddReferences_Call) RunAndReturn(run func(context.Context, string, []objects.BatchReference) replica.SimpleResponse) *MockShardLike_prepareAddReferences_Call {
	_c.Call.Return(run)
	return _c
}

// prepareDeleteObject provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockShardLike) prepareDeleteObject(_a0 context.Context, _a1 string, _a2 strfmt.UUID, _a3 time.Time) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1, _a2, _a3)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, strfmt.UUID, time.Time) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// prepareDeleteObject is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
//   - _a2 strfmt.UUID
//   - _a3 time.Time
func (_e *MockShardLike_Expecter) prepareDeleteObject(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}) *MockShardLike_prepareDeleteObject_Call {
	return &MockShardLike_prepareDeleteObject_Call{Call: _e.mock.On("prepareDeleteObject", _a0, _a1, _a2, _a3)}
}

func (_c *MockShardLike_prepareDeleteObject_Call) Run(run func(_a0 context.Context, _a1 string, _a2 strfmt.UUID, _a3 time.Time)) *MockShardLike_prepareDeleteObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(strfmt.UUID), args[3].(time.Time))
	})
	return _c
}

func (_c *MockShardLike_prepareDeleteObject_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_prepareDeleteObject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_prepareDeleteObject_Call) RunAndReturn(run func(context.Context, string, strfmt.UUID, time.Time) replica.SimpleResponse) *MockShardLike_prepareDeleteObject_Call {
	_c.Call.Return(run)
	return _c
}

// prepareDeleteObjects provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
func (_m *MockShardLike) prepareDeleteObjects(_a0 context.Context, _a1 string, _a2 []strfmt.UUID, _a3 time.Time, _a4 bool) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, []strfmt.UUID, time.Time, bool) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// prepareDeleteObjects is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
//   - _a2 []strfmt.UUID
//   - _a3 time.Time
//   - _a4 bool
func (_e *MockShardLike_Expecter) prepareDeleteObjects(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}, _a4 interface{}) *MockShardLike_prepareDeleteObjects_Call {
	return &MockShardLike_prepareDeleteObjects_Call{Call: _e.mock.On("prepareDeleteObjects", _a0, _a1, _a2, _a3, _a4)}
}

func (_c *MockShardLike_prepareDeleteObjects_Call) Run(run func(_a0 context.Context, _a1 string, _a2 []strfmt.UUID, _a3 time.Time, _a4 bool)) *MockShardLike_prepareDeleteObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]strfmt.UUID), args[3].(time.Time), args[4].(bool))
	})
	return _c
}

func (_c *MockShardLike_prepareDeleteObjects_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_prepareDeleteObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_prepareDeleteObjects_Call) RunAndReturn(run func(context.Context, string, []strfmt.UUID, time.Time, bool) replica.SimpleResponse) *MockShardLike_prepareDeleteObjects_Call {
	_c.Call.Return(run)
	return _c
}

// prepareMergeObject provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockShardLike) prepareMergeObject(_a0 context.Context, _a1 string, _a2 *objects.MergeDocument) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, *objects.MergeDocument) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// prepareMergeObject is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
//   - _a2 *objects.MergeDocument
func (_e *MockShardLike_Expecter) prepareMergeObject(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockShardLike_prepareMergeObject_Call {
	return &MockShardLike_prepareMergeObject_Call{Call: _e.mock.On("prepareMergeObject", _a0, _a1, _a2)}
}

func (_c *MockShardLike_prepareMergeObject_Call) Run(run func(_a0 context.Context, _a1 string, _a2 *objects.MergeDocument)) *MockShardLike_prepareMergeObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*objects.MergeDocument))
	})
	return _c
}

func (_c *MockShardLike_prepareMergeObject_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_prepareMergeObject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_prepareMergeObject_Call) RunAndReturn(run func(context.Context, string, *objects.MergeDocument) replica.SimpleResponse) *MockShardLike_prepareMergeObject_Call {
	_c.Call.Return(run)
	return _c
}

// preparePutObject provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockShardLike) preparePutObject(_a0 context.Context, _a1 string, _a2 *storobj.Object) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, *storobj.Object) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// preparePutObject is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
//   - _a2 *storobj.Object
func (_e *MockShardLike_Expecter) preparePutObject(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockShardLike_preparePutObject_Call {
	return &MockShardLike_preparePutObject_Call{Call: _e.mock.On("preparePutObject", _a0, _a1, _a2)}
}

func (_c *MockShardLike_preparePutObject_Call) Run(run func(_a0 context.Context, _a1 string, _a2 *storobj.Object)) *MockShardLike_preparePutObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*storobj.Object))
	})
	return _c
}

func (_c *MockShardLike_preparePutObject_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_preparePutObject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_preparePutObject_Call) RunAndReturn(run func(context.Context, string, *storobj.Object) replica.SimpleResponse) *MockShardLike_preparePutObject_Call {
	_c.Call.Return(run)
	return _c
}

// preparePutObjects provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockShardLike) preparePutObjects(_a0 context.Context, _a1 string, _a2 []*storobj.Object) replica.SimpleResponse {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, []*storobj.Object) replica.SimpleResponse); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

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

// preparePutObjects is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
//   - _a2 []*storobj.Object
func (_e *MockShardLike_Expecter) preparePutObjects(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockShardLike_preparePutObjects_Call {
	return &MockShardLike_preparePutObjects_Call{Call: _e.mock.On("preparePutObjects", _a0, _a1, _a2)}
}

func (_c *MockShardLike_preparePutObjects_Call) Run(run func(_a0 context.Context, _a1 string, _a2 []*storobj.Object)) *MockShardLike_preparePutObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]*storobj.Object))
	})
	return _c
}

func (_c *MockShardLike_preparePutObjects_Call) Return(_a0 replica.SimpleResponse) *MockShardLike_preparePutObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardLike_preparePutObjects_Call) RunAndReturn(run func(context.Context, string, []*storobj.Object) replica.SimpleResponse) *MockShardLike_preparePutObjects_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

// preventShutdown is a helper method to define mock.On call
func (_e *MockShardLike_Expecter) preventShutdown() *MockShardLike_preventShutdown_Call {
	return &MockShardLike_preventShutdown_Call{Call: _e.mock.On("preventShutdown")}
}

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

func (_c *MockShardLike_preventShutdown_Call) Return(release func(), err error) *MockShardLike_preventShutdown_Call {
	_c.Call.Return(release, err)
	return _c
}

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

// putObjectLSM provides a mock function with given fields: object, idBytes
func (_m *MockShardLike) putObjectLSM(object *storobj.Object, idBytes []byte) (objectInsertStatus, error) {
	ret := _m.Called(object, idBytes)

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

	var r0 objectInsertStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(*storobj.Object, []byte) (objectInsertStatus, error)); ok {
		return rf(object, idBytes)
	}
	if rf, ok := ret.Get(0).(func(*storobj.Object, []byte) objectInsertStatus); ok {
		r0 = rf(object, idBytes)
	} else {
		r0 = ret.Get(0).(objectInsertStatus)
	}

	if rf, ok := ret.Get(1).(func(*storobj.Object, []byte) error); ok {
		r1 = rf(object, idBytes)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// putObjectLSM is a helper method to define mock.On call
//   - object *storobj.Object
//   - idBytes []byte
func (_e *MockShardLike_Expecter) putObjectLSM(object interface{}, idBytes interface{}) *MockShardLike_putObjectLSM_Call {
	return &MockShardLike_putObjectLSM_Call{Call: _e.mock.On("putObjectLSM", object, idBytes)}
}

func (_c *MockShardLike_putObjectLSM_Call) Run(run func(object *storobj.Object, idBytes []byte)) *MockShardLike_putObjectLSM_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*storobj.Object), args[1].([]byte))
	})
	return _c
}

func (_c *MockShardLike_putObjectLSM_Call) Return(_a0 objectInsertStatus, _a1 error) *MockShardLike_putObjectLSM_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_putObjectLSM_Call) RunAndReturn(run func(*storobj.Object, []byte) (objectInsertStatus, error)) *MockShardLike_putObjectLSM_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

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

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

// removeTargetNodeOverride provides a mock function with given fields: ctx, targetNodeOverride
func (_m *MockShardLike) removeTargetNodeOverride(ctx context.Context, targetNodeOverride additional.AsyncReplicationTargetNodeOverride) error {
	ret := _m.Called(ctx, targetNodeOverride)

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

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

	return r0
}

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

// removeTargetNodeOverride is a helper method to define mock.On call
//   - ctx context.Context
//   - targetNodeOverride additional.AsyncReplicationTargetNodeOverride
func (_e *MockShardLike_Expecter) removeTargetNodeOverride(ctx interface{}, targetNodeOverride interface{}) *MockShardLike_removeTargetNodeOverride_Call {
	return &MockShardLike_removeTargetNodeOverride_Call{Call: _e.mock.On("removeTargetNodeOverride", ctx, targetNodeOverride)}
}

func (_c *MockShardLike_removeTargetNodeOverride_Call) Run(run func(ctx context.Context, targetNodeOverride additional.AsyncReplicationTargetNodeOverride)) *MockShardLike_removeTargetNodeOverride_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(additional.AsyncReplicationTargetNodeOverride))
	})
	return _c
}

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

func (_c *MockShardLike_removeTargetNodeOverride_Call) RunAndReturn(run func(context.Context, additional.AsyncReplicationTargetNodeOverride) error) *MockShardLike_removeTargetNodeOverride_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

// setFallbackToSearchable provides a mock function with given fields: fallback
func (_m *MockShardLike) setFallbackToSearchable(fallback bool) {
	_m.Called(fallback)
}

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

// setFallbackToSearchable is a helper method to define mock.On call
//   - fallback bool
func (_e *MockShardLike_Expecter) setFallbackToSearchable(fallback interface{}) *MockShardLike_setFallbackToSearchable_Call {
	return &MockShardLike_setFallbackToSearchable_Call{Call: _e.mock.On("setFallbackToSearchable", fallback)}
}

func (_c *MockShardLike_setFallbackToSearchable_Call) Run(run func(fallback bool)) *MockShardLike_setFallbackToSearchable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

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

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

// updateMultiVectorIndexesIgnoreDelete provides a mock function with given fields: ctx, multiVectors, status
func (_m *MockShardLike) updateMultiVectorIndexesIgnoreDelete(ctx context.Context, multiVectors map[string][][]float32, status objectInsertStatus) error {
	ret := _m.Called(ctx, multiVectors, status)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, map[string][][]float32, objectInsertStatus) error); ok {
		r0 = rf(ctx, multiVectors, status)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// updateMultiVectorIndexesIgnoreDelete is a helper method to define mock.On call
//   - ctx context.Context
//   - multiVectors map[string][][]float32
//   - status objectInsertStatus
func (_e *MockShardLike_Expecter) updateMultiVectorIndexesIgnoreDelete(ctx interface{}, multiVectors interface{}, status interface{}) *MockShardLike_updateMultiVectorIndexesIgnoreDelete_Call {
	return &MockShardLike_updateMultiVectorIndexesIgnoreDelete_Call{Call: _e.mock.On("updateMultiVectorIndexesIgnoreDelete", ctx, multiVectors, status)}
}

func (_c *MockShardLike_updateMultiVectorIndexesIgnoreDelete_Call) Run(run func(ctx context.Context, multiVectors map[string][][]float32, status objectInsertStatus)) *MockShardLike_updateMultiVectorIndexesIgnoreDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(map[string][][]float32), args[2].(objectInsertStatus))
	})
	return _c
}

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

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

// updatePropertySpecificIndices provides a mock function with given fields: ctx, object, status
func (_m *MockShardLike) updatePropertySpecificIndices(ctx context.Context, object *storobj.Object, status objectInsertStatus) error {
	ret := _m.Called(ctx, object, status)

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

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

	return r0
}

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

// updatePropertySpecificIndices is a helper method to define mock.On call
//   - ctx context.Context
//   - object *storobj.Object
//   - status objectInsertStatus
func (_e *MockShardLike_Expecter) updatePropertySpecificIndices(ctx interface{}, object interface{}, status interface{}) *MockShardLike_updatePropertySpecificIndices_Call {
	return &MockShardLike_updatePropertySpecificIndices_Call{Call: _e.mock.On("updatePropertySpecificIndices", ctx, object, status)}
}

func (_c *MockShardLike_updatePropertySpecificIndices_Call) Run(run func(ctx context.Context, object *storobj.Object, status objectInsertStatus)) *MockShardLike_updatePropertySpecificIndices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*storobj.Object), args[2].(objectInsertStatus))
	})
	return _c
}

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

func (_c *MockShardLike_updatePropertySpecificIndices_Call) RunAndReturn(run func(context.Context, *storobj.Object, objectInsertStatus) error) *MockShardLike_updatePropertySpecificIndices_Call {
	_c.Call.Return(run)
	return _c
}

// updateVectorIndexIgnoreDelete provides a mock function with given fields: ctx, vector, status
func (_m *MockShardLike) updateVectorIndexIgnoreDelete(ctx context.Context, vector []float32, status objectInsertStatus) error {
	ret := _m.Called(ctx, vector, status)

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

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

	return r0
}

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

// updateVectorIndexIgnoreDelete is a helper method to define mock.On call
//   - ctx context.Context
//   - vector []float32
//   - status objectInsertStatus
func (_e *MockShardLike_Expecter) updateVectorIndexIgnoreDelete(ctx interface{}, vector interface{}, status interface{}) *MockShardLike_updateVectorIndexIgnoreDelete_Call {
	return &MockShardLike_updateVectorIndexIgnoreDelete_Call{Call: _e.mock.On("updateVectorIndexIgnoreDelete", ctx, vector, status)}
}

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

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

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

// updateVectorIndexesIgnoreDelete provides a mock function with given fields: ctx, vectors, status
func (_m *MockShardLike) updateVectorIndexesIgnoreDelete(ctx context.Context, vectors map[string][]float32, status objectInsertStatus) error {
	ret := _m.Called(ctx, vectors, status)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, map[string][]float32, objectInsertStatus) error); ok {
		r0 = rf(ctx, vectors, status)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// updateVectorIndexesIgnoreDelete is a helper method to define mock.On call
//   - ctx context.Context
//   - vectors map[string][]float32
//   - status objectInsertStatus
func (_e *MockShardLike_Expecter) updateVectorIndexesIgnoreDelete(ctx interface{}, vectors interface{}, status interface{}) *MockShardLike_updateVectorIndexesIgnoreDelete_Call {
	return &MockShardLike_updateVectorIndexesIgnoreDelete_Call{Call: _e.mock.On("updateVectorIndexesIgnoreDelete", ctx, vectors, status)}
}

func (_c *MockShardLike_updateVectorIndexesIgnoreDelete_Call) Run(run func(ctx context.Context, vectors map[string][]float32, status objectInsertStatus)) *MockShardLike_updateVectorIndexesIgnoreDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(map[string][]float32), args[2].(objectInsertStatus))
	})
	return _c
}

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

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

// uuidFromDocID provides a mock function with given fields: docID
func (_m *MockShardLike) uuidFromDocID(docID uint64) (strfmt.UUID, error) {
	ret := _m.Called(docID)

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

	var r0 strfmt.UUID
	var r1 error
	if rf, ok := ret.Get(0).(func(uint64) (strfmt.UUID, error)); ok {
		return rf(docID)
	}
	if rf, ok := ret.Get(0).(func(uint64) strfmt.UUID); ok {
		r0 = rf(docID)
	} else {
		r0 = ret.Get(0).(strfmt.UUID)
	}

	if rf, ok := ret.Get(1).(func(uint64) error); ok {
		r1 = rf(docID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockShardLike_uuidFromDocID_Call) Return(_a0 strfmt.UUID, _a1 error) *MockShardLike_uuidFromDocID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardLike_uuidFromDocID_Call) RunAndReturn(run func(uint64) (strfmt.UUID, error)) *MockShardLike_uuidFromDocID_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockShardLike creates a new instance of MockShardLike. 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 NewMockShardLike(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockShardLike {
	mock := &MockShardLike{}
	mock.Mock.Test(t)

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

	return mock
}
