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

package delegator

import (
	context "context"

	milvuspb "github.com/milvus-io/milvus-proto/go-api/v3/milvuspb"
	schemapb "github.com/milvus-io/milvus-proto/go-api/v3/schemapb"
	streamrpc "github.com/milvus-io/milvus/internal/util/streamrpc"
	internalpb "github.com/milvus-io/milvus/pkg/v3/proto/internalpb"
	querypb "github.com/milvus-io/milvus/pkg/v3/proto/querypb"
	mock "github.com/stretchr/testify/mock"
)

// MockShardDelegator is an autogenerated mock type for the ShardDelegator type
type MockShardDelegator struct {
	mock.Mock
}

type MockShardDelegator_Expecter struct {
	mock *mock.Mock
}

func (_m *MockShardDelegator) EXPECT() *MockShardDelegator_Expecter {
	return &MockShardDelegator_Expecter{mock: &_m.Mock}
}

// AddExcludedSegments provides a mock function with given fields: excludeInfo
func (_m *MockShardDelegator) AddExcludedSegments(excludeInfo map[int64]uint64) {
	_m.Called(excludeInfo)
}

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

// AddExcludedSegments is a helper method to define mock.On call
//   - excludeInfo map[int64]uint64
func (_e *MockShardDelegator_Expecter) AddExcludedSegments(excludeInfo interface{}) *MockShardDelegator_AddExcludedSegments_Call {
	return &MockShardDelegator_AddExcludedSegments_Call{Call: _e.mock.On("AddExcludedSegments", excludeInfo)}
}

func (_c *MockShardDelegator_AddExcludedSegments_Call) Run(run func(excludeInfo map[int64]uint64)) *MockShardDelegator_AddExcludedSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(map[int64]uint64))
	})
	return _c
}

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

func (_c *MockShardDelegator_AddExcludedSegments_Call) RunAndReturn(run func(map[int64]uint64)) *MockShardDelegator_AddExcludedSegments_Call {
	_c.Run(run)
	return _c
}

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

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

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

	return r0
}

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

// CatchingUpStreamingData is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) CatchingUpStreamingData() *MockShardDelegator_CatchingUpStreamingData_Call {
	return &MockShardDelegator_CatchingUpStreamingData_Call{Call: _e.mock.On("CatchingUpStreamingData")}
}

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

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

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) Close() *MockShardDelegator_Close_Call {
	return &MockShardDelegator_Close_Call{Call: _e.mock.On("Close")}
}

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

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

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

// Collection provides a mock function with no fields
func (_m *MockShardDelegator) Collection() int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// Collection is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) Collection() *MockShardDelegator_Collection_Call {
	return &MockShardDelegator_Collection_Call{Call: _e.mock.On("Collection")}
}

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

func (_c *MockShardDelegator_Collection_Call) Return(_a0 int64) *MockShardDelegator_Collection_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardDelegator_Collection_Call) RunAndReturn(run func() int64) *MockShardDelegator_Collection_Call {
	_c.Call.Return(run)
	return _c
}

// GetChannelQueryView provides a mock function with no fields
func (_m *MockShardDelegator) GetChannelQueryView() *channelQueryView {
	ret := _m.Called()

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

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

	return r0
}

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

// GetChannelQueryView is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) GetChannelQueryView() *MockShardDelegator_GetChannelQueryView_Call {
	return &MockShardDelegator_GetChannelQueryView_Call{Call: _e.mock.On("GetChannelQueryView")}
}

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

func (_c *MockShardDelegator_GetChannelQueryView_Call) Return(_a0 *channelQueryView) *MockShardDelegator_GetChannelQueryView_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardDelegator_GetChannelQueryView_Call) RunAndReturn(run func() *channelQueryView) *MockShardDelegator_GetChannelQueryView_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeleteBufferSize provides a mock function with no fields
func (_m *MockShardDelegator) GetDeleteBufferSize() (int64, int64) {
	ret := _m.Called()

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

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

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

	return r0, r1
}

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

// GetDeleteBufferSize is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) GetDeleteBufferSize() *MockShardDelegator_GetDeleteBufferSize_Call {
	return &MockShardDelegator_GetDeleteBufferSize_Call{Call: _e.mock.On("GetDeleteBufferSize")}
}

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

func (_c *MockShardDelegator_GetDeleteBufferSize_Call) Return(entryNum int64, memorySize int64) *MockShardDelegator_GetDeleteBufferSize_Call {
	_c.Call.Return(entryNum, memorySize)
	return _c
}

func (_c *MockShardDelegator_GetDeleteBufferSize_Call) RunAndReturn(run func() (int64, int64)) *MockShardDelegator_GetDeleteBufferSize_Call {
	_c.Call.Return(run)
	return _c
}

// GetHighlight provides a mock function with given fields: ctx, req
func (_m *MockShardDelegator) GetHighlight(ctx context.Context, req *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error) {
	ret := _m.Called(ctx, req)

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

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

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

	return r0, r1
}

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

// GetHighlight is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.GetHighlightRequest
func (_e *MockShardDelegator_Expecter) GetHighlight(ctx interface{}, req interface{}) *MockShardDelegator_GetHighlight_Call {
	return &MockShardDelegator_GetHighlight_Call{Call: _e.mock.On("GetHighlight", ctx, req)}
}

func (_c *MockShardDelegator_GetHighlight_Call) Run(run func(ctx context.Context, req *querypb.GetHighlightRequest)) *MockShardDelegator_GetHighlight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.GetHighlightRequest))
	})
	return _c
}

func (_c *MockShardDelegator_GetHighlight_Call) Return(_a0 []*querypb.HighlightResult, _a1 error) *MockShardDelegator_GetHighlight_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardDelegator_GetHighlight_Call) RunAndReturn(run func(context.Context, *querypb.GetHighlightRequest) ([]*querypb.HighlightResult, error)) *MockShardDelegator_GetHighlight_Call {
	_c.Call.Return(run)
	return _c
}

// GetLatestRequiredMVCCTimeTick provides a mock function with no fields
func (_m *MockShardDelegator) GetLatestRequiredMVCCTimeTick() uint64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetLatestRequiredMVCCTimeTick is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) GetLatestRequiredMVCCTimeTick() *MockShardDelegator_GetLatestRequiredMVCCTimeTick_Call {
	return &MockShardDelegator_GetLatestRequiredMVCCTimeTick_Call{Call: _e.mock.On("GetLatestRequiredMVCCTimeTick")}
}

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

func (_c *MockShardDelegator_GetLatestRequiredMVCCTimeTick_Call) Return(_a0 uint64) *MockShardDelegator_GetLatestRequiredMVCCTimeTick_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetPartitionStatsVersions provides a mock function with given fields: ctx
func (_m *MockShardDelegator) GetPartitionStatsVersions(ctx context.Context) map[int64]int64 {
	ret := _m.Called(ctx)

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

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

	return r0
}

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

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

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

func (_c *MockShardDelegator_GetPartitionStatsVersions_Call) Return(_a0 map[int64]int64) *MockShardDelegator_GetPartitionStatsVersions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardDelegator_GetPartitionStatsVersions_Call) RunAndReturn(run func(context.Context) map[int64]int64) *MockShardDelegator_GetPartitionStatsVersions_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentInfo provides a mock function with given fields: readable
func (_m *MockShardDelegator) GetSegmentInfo(readable bool) ([]SnapshotItem, []SegmentEntry) {
	ret := _m.Called(readable)

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

	var r0 []SnapshotItem
	var r1 []SegmentEntry
	if rf, ok := ret.Get(0).(func(bool) ([]SnapshotItem, []SegmentEntry)); ok {
		return rf(readable)
	}
	if rf, ok := ret.Get(0).(func(bool) []SnapshotItem); ok {
		r0 = rf(readable)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]SnapshotItem)
		}
	}

	if rf, ok := ret.Get(1).(func(bool) []SegmentEntry); ok {
		r1 = rf(readable)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]SegmentEntry)
		}
	}

	return r0, r1
}

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

// GetSegmentInfo is a helper method to define mock.On call
//   - readable bool
func (_e *MockShardDelegator_Expecter) GetSegmentInfo(readable interface{}) *MockShardDelegator_GetSegmentInfo_Call {
	return &MockShardDelegator_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", readable)}
}

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

func (_c *MockShardDelegator_GetSegmentInfo_Call) Return(sealed []SnapshotItem, growing []SegmentEntry) *MockShardDelegator_GetSegmentInfo_Call {
	_c.Call.Return(sealed, growing)
	return _c
}

func (_c *MockShardDelegator_GetSegmentInfo_Call) RunAndReturn(run func(bool) ([]SnapshotItem, []SegmentEntry)) *MockShardDelegator_GetSegmentInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatistics provides a mock function with given fields: ctx, req
func (_m *MockShardDelegator) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) ([]*internalpb.GetStatisticsResponse, error) {
	ret := _m.Called(ctx, req)

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

	var r0 []*internalpb.GetStatisticsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) ([]*internalpb.GetStatisticsResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) []*internalpb.GetStatisticsResponse); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*internalpb.GetStatisticsResponse)
		}
	}

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

	return r0, r1
}

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

// GetStatistics is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.GetStatisticsRequest
func (_e *MockShardDelegator_Expecter) GetStatistics(ctx interface{}, req interface{}) *MockShardDelegator_GetStatistics_Call {
	return &MockShardDelegator_GetStatistics_Call{Call: _e.mock.On("GetStatistics", ctx, req)}
}

func (_c *MockShardDelegator_GetStatistics_Call) Run(run func(ctx context.Context, req *querypb.GetStatisticsRequest)) *MockShardDelegator_GetStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.GetStatisticsRequest))
	})
	return _c
}

func (_c *MockShardDelegator_GetStatistics_Call) Return(_a0 []*internalpb.GetStatisticsResponse, _a1 error) *MockShardDelegator_GetStatistics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardDelegator_GetStatistics_Call) RunAndReturn(run func(context.Context, *querypb.GetStatisticsRequest) ([]*internalpb.GetStatisticsResponse, error)) *MockShardDelegator_GetStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// GetTSafe provides a mock function with no fields
func (_m *MockShardDelegator) GetTSafe() uint64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetTSafe is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) GetTSafe() *MockShardDelegator_GetTSafe_Call {
	return &MockShardDelegator_GetTSafe_Call{Call: _e.mock.On("GetTSafe")}
}

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

func (_c *MockShardDelegator_GetTSafe_Call) Return(_a0 uint64) *MockShardDelegator_GetTSafe_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// LoadGrowing provides a mock function with given fields: ctx, infos, version
func (_m *MockShardDelegator) LoadGrowing(ctx context.Context, infos []*querypb.SegmentLoadInfo, version int64) error {
	ret := _m.Called(ctx, infos, version)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*querypb.SegmentLoadInfo, int64) error); ok {
		r0 = rf(ctx, infos, version)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LoadGrowing is a helper method to define mock.On call
//   - ctx context.Context
//   - infos []*querypb.SegmentLoadInfo
//   - version int64
func (_e *MockShardDelegator_Expecter) LoadGrowing(ctx interface{}, infos interface{}, version interface{}) *MockShardDelegator_LoadGrowing_Call {
	return &MockShardDelegator_LoadGrowing_Call{Call: _e.mock.On("LoadGrowing", ctx, infos, version)}
}

func (_c *MockShardDelegator_LoadGrowing_Call) Run(run func(ctx context.Context, infos []*querypb.SegmentLoadInfo, version int64)) *MockShardDelegator_LoadGrowing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*querypb.SegmentLoadInfo), args[2].(int64))
	})
	return _c
}

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

func (_c *MockShardDelegator_LoadGrowing_Call) RunAndReturn(run func(context.Context, []*querypb.SegmentLoadInfo, int64) error) *MockShardDelegator_LoadGrowing_Call {
	_c.Call.Return(run)
	return _c
}

// LoadL0 provides a mock function with given fields: ctx, infos, version
func (_m *MockShardDelegator) LoadL0(ctx context.Context, infos []*querypb.SegmentLoadInfo, version int64) error {
	ret := _m.Called(ctx, infos, version)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*querypb.SegmentLoadInfo, int64) error); ok {
		r0 = rf(ctx, infos, version)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LoadL0 is a helper method to define mock.On call
//   - ctx context.Context
//   - infos []*querypb.SegmentLoadInfo
//   - version int64
func (_e *MockShardDelegator_Expecter) LoadL0(ctx interface{}, infos interface{}, version interface{}) *MockShardDelegator_LoadL0_Call {
	return &MockShardDelegator_LoadL0_Call{Call: _e.mock.On("LoadL0", ctx, infos, version)}
}

func (_c *MockShardDelegator_LoadL0_Call) Run(run func(ctx context.Context, infos []*querypb.SegmentLoadInfo, version int64)) *MockShardDelegator_LoadL0_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*querypb.SegmentLoadInfo), args[2].(int64))
	})
	return _c
}

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

func (_c *MockShardDelegator_LoadL0_Call) RunAndReturn(run func(context.Context, []*querypb.SegmentLoadInfo, int64) error) *MockShardDelegator_LoadL0_Call {
	_c.Call.Return(run)
	return _c
}

// LoadSegments provides a mock function with given fields: ctx, req
func (_m *MockShardDelegator) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) error {
	ret := _m.Called(ctx, req)

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

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

	return r0
}

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

// LoadSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.LoadSegmentsRequest
func (_e *MockShardDelegator_Expecter) LoadSegments(ctx interface{}, req interface{}) *MockShardDelegator_LoadSegments_Call {
	return &MockShardDelegator_LoadSegments_Call{Call: _e.mock.On("LoadSegments", ctx, req)}
}

func (_c *MockShardDelegator_LoadSegments_Call) Run(run func(ctx context.Context, req *querypb.LoadSegmentsRequest)) *MockShardDelegator_LoadSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.LoadSegmentsRequest))
	})
	return _c
}

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

func (_c *MockShardDelegator_LoadSegments_Call) RunAndReturn(run func(context.Context, *querypb.LoadSegmentsRequest) error) *MockShardDelegator_LoadSegments_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessDelete provides a mock function with given fields: deleteData, ts
func (_m *MockShardDelegator) ProcessDelete(deleteData []*DeleteData, ts uint64) {
	_m.Called(deleteData, ts)
}

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

// ProcessDelete is a helper method to define mock.On call
//   - deleteData []*DeleteData
//   - ts uint64
func (_e *MockShardDelegator_Expecter) ProcessDelete(deleteData interface{}, ts interface{}) *MockShardDelegator_ProcessDelete_Call {
	return &MockShardDelegator_ProcessDelete_Call{Call: _e.mock.On("ProcessDelete", deleteData, ts)}
}

func (_c *MockShardDelegator_ProcessDelete_Call) Run(run func(deleteData []*DeleteData, ts uint64)) *MockShardDelegator_ProcessDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]*DeleteData), args[1].(uint64))
	})
	return _c
}

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

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

// ProcessDeleteBatches provides a mock function with given fields: batches
func (_m *MockShardDelegator) ProcessDeleteBatches(batches []DeleteBatch) {
	_m.Called(batches)
}

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

// ProcessDeleteBatches is a helper method to define mock.On call
//   - batches []DeleteBatch
func (_e *MockShardDelegator_Expecter) ProcessDeleteBatches(batches interface{}) *MockShardDelegator_ProcessDeleteBatches_Call {
	return &MockShardDelegator_ProcessDeleteBatches_Call{Call: _e.mock.On("ProcessDeleteBatches", batches)}
}

func (_c *MockShardDelegator_ProcessDeleteBatches_Call) Run(run func(batches []DeleteBatch)) *MockShardDelegator_ProcessDeleteBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]DeleteBatch))
	})
	return _c
}

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

func (_c *MockShardDelegator_ProcessDeleteBatches_Call) RunAndReturn(run func([]DeleteBatch)) *MockShardDelegator_ProcessDeleteBatches_Call {
	_c.Run(run)
	return _c
}

// ProcessInsert provides a mock function with given fields: insertRecords
func (_m *MockShardDelegator) ProcessInsert(insertRecords map[int64]*InsertData) {
	_m.Called(insertRecords)
}

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

// ProcessInsert is a helper method to define mock.On call
//   - insertRecords map[int64]*InsertData
func (_e *MockShardDelegator_Expecter) ProcessInsert(insertRecords interface{}) *MockShardDelegator_ProcessInsert_Call {
	return &MockShardDelegator_ProcessInsert_Call{Call: _e.mock.On("ProcessInsert", insertRecords)}
}

func (_c *MockShardDelegator_ProcessInsert_Call) Run(run func(insertRecords map[int64]*InsertData)) *MockShardDelegator_ProcessInsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(map[int64]*InsertData))
	})
	return _c
}

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

func (_c *MockShardDelegator_ProcessInsert_Call) RunAndReturn(run func(map[int64]*InsertData)) *MockShardDelegator_ProcessInsert_Call {
	_c.Run(run)
	return _c
}

// Query provides a mock function with given fields: ctx, req
func (_m *MockShardDelegator) Query(ctx context.Context, req *querypb.QueryRequest) ([]*internalpb.RetrieveResults, error) {
	ret := _m.Called(ctx, req)

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

	var r0 []*internalpb.RetrieveResults
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) ([]*internalpb.RetrieveResults, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) []*internalpb.RetrieveResults); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*internalpb.RetrieveResults)
		}
	}

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

	return r0, r1
}

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

// Query is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.QueryRequest
func (_e *MockShardDelegator_Expecter) Query(ctx interface{}, req interface{}) *MockShardDelegator_Query_Call {
	return &MockShardDelegator_Query_Call{Call: _e.mock.On("Query", ctx, req)}
}

func (_c *MockShardDelegator_Query_Call) Run(run func(ctx context.Context, req *querypb.QueryRequest)) *MockShardDelegator_Query_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.QueryRequest))
	})
	return _c
}

func (_c *MockShardDelegator_Query_Call) Return(_a0 []*internalpb.RetrieveResults, _a1 error) *MockShardDelegator_Query_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardDelegator_Query_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest) ([]*internalpb.RetrieveResults, error)) *MockShardDelegator_Query_Call {
	_c.Call.Return(run)
	return _c
}

// QueryStream provides a mock function with given fields: ctx, req, srv
func (_m *MockShardDelegator) QueryStream(ctx context.Context, req *querypb.QueryRequest, srv streamrpc.QueryStreamServer) error {
	ret := _m.Called(ctx, req, srv)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest, streamrpc.QueryStreamServer) error); ok {
		r0 = rf(ctx, req, srv)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// QueryStream is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.QueryRequest
//   - srv streamrpc.QueryStreamServer
func (_e *MockShardDelegator_Expecter) QueryStream(ctx interface{}, req interface{}, srv interface{}) *MockShardDelegator_QueryStream_Call {
	return &MockShardDelegator_QueryStream_Call{Call: _e.mock.On("QueryStream", ctx, req, srv)}
}

func (_c *MockShardDelegator_QueryStream_Call) Run(run func(ctx context.Context, req *querypb.QueryRequest, srv streamrpc.QueryStreamServer)) *MockShardDelegator_QueryStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.QueryRequest), args[2].(streamrpc.QueryStreamServer))
	})
	return _c
}

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

func (_c *MockShardDelegator_QueryStream_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest, streamrpc.QueryStreamServer) error) *MockShardDelegator_QueryStream_Call {
	_c.Call.Return(run)
	return _c
}

// ReleaseSegments provides a mock function with given fields: ctx, req, force
func (_m *MockShardDelegator) ReleaseSegments(ctx context.Context, req *querypb.ReleaseSegmentsRequest, force bool) error {
	ret := _m.Called(ctx, req, force)

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

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

	return r0
}

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

// ReleaseSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.ReleaseSegmentsRequest
//   - force bool
func (_e *MockShardDelegator_Expecter) ReleaseSegments(ctx interface{}, req interface{}, force interface{}) *MockShardDelegator_ReleaseSegments_Call {
	return &MockShardDelegator_ReleaseSegments_Call{Call: _e.mock.On("ReleaseSegments", ctx, req, force)}
}

func (_c *MockShardDelegator_ReleaseSegments_Call) Run(run func(ctx context.Context, req *querypb.ReleaseSegmentsRequest, force bool)) *MockShardDelegator_ReleaseSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.ReleaseSegmentsRequest), args[2].(bool))
	})
	return _c
}

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

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

// RunAnalyzer provides a mock function with given fields: ctx, req
func (_m *MockShardDelegator) RunAnalyzer(ctx context.Context, req *querypb.RunAnalyzerRequest) ([]*milvuspb.AnalyzerResult, error) {
	ret := _m.Called(ctx, req)

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

	var r0 []*milvuspb.AnalyzerResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.RunAnalyzerRequest) ([]*milvuspb.AnalyzerResult, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.RunAnalyzerRequest) []*milvuspb.AnalyzerResult); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*milvuspb.AnalyzerResult)
		}
	}

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

	return r0, r1
}

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

// RunAnalyzer is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.RunAnalyzerRequest
func (_e *MockShardDelegator_Expecter) RunAnalyzer(ctx interface{}, req interface{}) *MockShardDelegator_RunAnalyzer_Call {
	return &MockShardDelegator_RunAnalyzer_Call{Call: _e.mock.On("RunAnalyzer", ctx, req)}
}

func (_c *MockShardDelegator_RunAnalyzer_Call) Run(run func(ctx context.Context, req *querypb.RunAnalyzerRequest)) *MockShardDelegator_RunAnalyzer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.RunAnalyzerRequest))
	})
	return _c
}

func (_c *MockShardDelegator_RunAnalyzer_Call) Return(_a0 []*milvuspb.AnalyzerResult, _a1 error) *MockShardDelegator_RunAnalyzer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardDelegator_RunAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.RunAnalyzerRequest) ([]*milvuspb.AnalyzerResult, error)) *MockShardDelegator_RunAnalyzer_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function with given fields: ctx, req
func (_m *MockShardDelegator) Search(ctx context.Context, req *querypb.SearchRequest) ([]*internalpb.SearchResults, error) {
	ret := _m.Called(ctx, req)

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

	var r0 []*internalpb.SearchResults
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) ([]*internalpb.SearchResults, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) []*internalpb.SearchResults); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*internalpb.SearchResults)
		}
	}

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

	return r0, r1
}

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

// Search is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.SearchRequest
func (_e *MockShardDelegator_Expecter) Search(ctx interface{}, req interface{}) *MockShardDelegator_Search_Call {
	return &MockShardDelegator_Search_Call{Call: _e.mock.On("Search", ctx, req)}
}

func (_c *MockShardDelegator_Search_Call) Run(run func(ctx context.Context, req *querypb.SearchRequest)) *MockShardDelegator_Search_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*querypb.SearchRequest))
	})
	return _c
}

func (_c *MockShardDelegator_Search_Call) Return(_a0 []*internalpb.SearchResults, _a1 error) *MockShardDelegator_Search_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardDelegator_Search_Call) RunAndReturn(run func(context.Context, *querypb.SearchRequest) ([]*internalpb.SearchResults, error)) *MockShardDelegator_Search_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Serviceable is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) Serviceable() *MockShardDelegator_Serviceable_Call {
	return &MockShardDelegator_Serviceable_Call{Call: _e.mock.On("Serviceable")}
}

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

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

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

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

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

// Start is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) Start() *MockShardDelegator_Start_Call {
	return &MockShardDelegator_Start_Call{Call: _e.mock.On("Start")}
}

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

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

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

// SyncDistribution provides a mock function with given fields: ctx, entries
func (_m *MockShardDelegator) SyncDistribution(ctx context.Context, entries ...SegmentEntry) {
	_va := make([]interface{}, len(entries))
	for _i := range entries {
		_va[_i] = entries[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	_m.Called(_ca...)
}

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

// SyncDistribution is a helper method to define mock.On call
//   - ctx context.Context
//   - entries ...SegmentEntry
func (_e *MockShardDelegator_Expecter) SyncDistribution(ctx interface{}, entries ...interface{}) *MockShardDelegator_SyncDistribution_Call {
	return &MockShardDelegator_SyncDistribution_Call{Call: _e.mock.On("SyncDistribution",
		append([]interface{}{ctx}, entries...)...)}
}

func (_c *MockShardDelegator_SyncDistribution_Call) Run(run func(ctx context.Context, entries ...SegmentEntry)) *MockShardDelegator_SyncDistribution_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]SegmentEntry, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(SegmentEntry)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

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

func (_c *MockShardDelegator_SyncDistribution_Call) RunAndReturn(run func(context.Context, ...SegmentEntry)) *MockShardDelegator_SyncDistribution_Call {
	_c.Run(run)
	return _c
}

// SyncPartitionStats provides a mock function with given fields: ctx, partVersions
func (_m *MockShardDelegator) SyncPartitionStats(ctx context.Context, partVersions map[int64]int64) {
	_m.Called(ctx, partVersions)
}

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

// SyncPartitionStats is a helper method to define mock.On call
//   - ctx context.Context
//   - partVersions map[int64]int64
func (_e *MockShardDelegator_Expecter) SyncPartitionStats(ctx interface{}, partVersions interface{}) *MockShardDelegator_SyncPartitionStats_Call {
	return &MockShardDelegator_SyncPartitionStats_Call{Call: _e.mock.On("SyncPartitionStats", ctx, partVersions)}
}

func (_c *MockShardDelegator_SyncPartitionStats_Call) Run(run func(ctx context.Context, partVersions map[int64]int64)) *MockShardDelegator_SyncPartitionStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(map[int64]int64))
	})
	return _c
}

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

func (_c *MockShardDelegator_SyncPartitionStats_Call) RunAndReturn(run func(context.Context, map[int64]int64)) *MockShardDelegator_SyncPartitionStats_Call {
	_c.Run(run)
	return _c
}

// SyncTargetVersion provides a mock function with given fields: action, partitions
func (_m *MockShardDelegator) SyncTargetVersion(action *querypb.SyncAction, partitions []int64) {
	_m.Called(action, partitions)
}

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

// SyncTargetVersion is a helper method to define mock.On call
//   - action *querypb.SyncAction
//   - partitions []int64
func (_e *MockShardDelegator_Expecter) SyncTargetVersion(action interface{}, partitions interface{}) *MockShardDelegator_SyncTargetVersion_Call {
	return &MockShardDelegator_SyncTargetVersion_Call{Call: _e.mock.On("SyncTargetVersion", action, partitions)}
}

func (_c *MockShardDelegator_SyncTargetVersion_Call) Run(run func(action *querypb.SyncAction, partitions []int64)) *MockShardDelegator_SyncTargetVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*querypb.SyncAction), args[1].([]int64))
	})
	return _c
}

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

func (_c *MockShardDelegator_SyncTargetVersion_Call) RunAndReturn(run func(*querypb.SyncAction, []int64)) *MockShardDelegator_SyncTargetVersion_Call {
	_c.Run(run)
	return _c
}

// TryCleanExcludedSegments provides a mock function with given fields: ts
func (_m *MockShardDelegator) TryCleanExcludedSegments(ts uint64) {
	_m.Called(ts)
}

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

// TryCleanExcludedSegments is a helper method to define mock.On call
//   - ts uint64
func (_e *MockShardDelegator_Expecter) TryCleanExcludedSegments(ts interface{}) *MockShardDelegator_TryCleanExcludedSegments_Call {
	return &MockShardDelegator_TryCleanExcludedSegments_Call{Call: _e.mock.On("TryCleanExcludedSegments", ts)}
}

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

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

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

// UpdateSchema provides a mock function with given fields: ctx, sch, schemaBarrierTs
func (_m *MockShardDelegator) UpdateSchema(ctx context.Context, sch *schemapb.CollectionSchema, schemaBarrierTs uint64) error {
	ret := _m.Called(ctx, sch, schemaBarrierTs)

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

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

	return r0
}

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

// UpdateSchema is a helper method to define mock.On call
//   - ctx context.Context
//   - sch *schemapb.CollectionSchema
//   - schemaBarrierTs uint64
func (_e *MockShardDelegator_Expecter) UpdateSchema(ctx interface{}, sch interface{}, schemaBarrierTs interface{}) *MockShardDelegator_UpdateSchema_Call {
	return &MockShardDelegator_UpdateSchema_Call{Call: _e.mock.On("UpdateSchema", ctx, sch, schemaBarrierTs)}
}

func (_c *MockShardDelegator_UpdateSchema_Call) Run(run func(ctx context.Context, sch *schemapb.CollectionSchema, schemaBarrierTs uint64)) *MockShardDelegator_UpdateSchema_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*schemapb.CollectionSchema), args[2].(uint64))
	})
	return _c
}

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

func (_c *MockShardDelegator_UpdateSchema_Call) RunAndReturn(run func(context.Context, *schemapb.CollectionSchema, uint64) error) *MockShardDelegator_UpdateSchema_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTSafe provides a mock function with given fields: ts
func (_m *MockShardDelegator) UpdateTSafe(ts uint64) {
	_m.Called(ts)
}

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

// UpdateTSafe is a helper method to define mock.On call
//   - ts uint64
func (_e *MockShardDelegator_Expecter) UpdateTSafe(ts interface{}) *MockShardDelegator_UpdateTSafe_Call {
	return &MockShardDelegator_UpdateTSafe_Call{Call: _e.mock.On("UpdateTSafe", ts)}
}

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

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

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

// VerifyExcludedSegments provides a mock function with given fields: segmentID, ts
func (_m *MockShardDelegator) VerifyExcludedSegments(segmentID int64, ts uint64) bool {
	ret := _m.Called(segmentID, ts)

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

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

	return r0
}

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

// VerifyExcludedSegments is a helper method to define mock.On call
//   - segmentID int64
//   - ts uint64
func (_e *MockShardDelegator_Expecter) VerifyExcludedSegments(segmentID interface{}, ts interface{}) *MockShardDelegator_VerifyExcludedSegments_Call {
	return &MockShardDelegator_VerifyExcludedSegments_Call{Call: _e.mock.On("VerifyExcludedSegments", segmentID, ts)}
}

func (_c *MockShardDelegator_VerifyExcludedSegments_Call) Run(run func(segmentID int64, ts uint64)) *MockShardDelegator_VerifyExcludedSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(uint64))
	})
	return _c
}

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

func (_c *MockShardDelegator_VerifyExcludedSegments_Call) RunAndReturn(run func(int64, uint64) bool) *MockShardDelegator_VerifyExcludedSegments_Call {
	_c.Call.Return(run)
	return _c
}

// Version provides a mock function with no fields
func (_m *MockShardDelegator) Version() int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// Version is a helper method to define mock.On call
func (_e *MockShardDelegator_Expecter) Version() *MockShardDelegator_Version_Call {
	return &MockShardDelegator_Version_Call{Call: _e.mock.On("Version")}
}

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

func (_c *MockShardDelegator_Version_Call) Return(_a0 int64) *MockShardDelegator_Version_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardDelegator_Version_Call) RunAndReturn(run func() int64) *MockShardDelegator_Version_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockShardDelegator creates a new instance of MockShardDelegator. 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 NewMockShardDelegator(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockShardDelegator {
	mock := &MockShardDelegator{}
	mock.Mock.Test(t)

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

	return mock
}
