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

package mocks

import (
	context "context"

	commonpb "github.com/milvus-io/milvus-proto/go-api/v3/commonpb"
	clientv3 "go.etcd.io/etcd/client/v3"

	datapb "github.com/milvus-io/milvus/pkg/v3/proto/datapb"

	indexpb "github.com/milvus-io/milvus/pkg/v3/proto/indexpb"

	internalpb "github.com/milvus-io/milvus/pkg/v3/proto/internalpb"

	milvuspb "github.com/milvus-io/milvus-proto/go-api/v3/milvuspb"

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

	txnkv "github.com/tikv/client-go/v2/txnkv"

	types "github.com/milvus-io/milvus/internal/types"
)

// MockDataCoord is an autogenerated mock type for the DataCoordComponent type
type MockDataCoord struct {
	mock.Mock
}

type MockDataCoord_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDataCoord) EXPECT() *MockDataCoord_Expecter {
	return &MockDataCoord_Expecter{mock: &_m.Mock}
}

// AbortImport provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) AbortImport(_a0 context.Context, _a1 *datapb.AbortImportRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AbortImportRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AbortImportRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// AbortImport is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.AbortImportRequest
func (_e *MockDataCoord_Expecter) AbortImport(_a0 interface{}, _a1 interface{}) *MockDataCoord_AbortImport_Call {
	return &MockDataCoord_AbortImport_Call{Call: _e.mock.On("AbortImport", _a0, _a1)}
}

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

func (_c *MockDataCoord_AbortImport_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_AbortImport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_AbortImport_Call) RunAndReturn(run func(context.Context, *datapb.AbortImportRequest) (*commonpb.Status, error)) *MockDataCoord_AbortImport_Call {
	_c.Call.Return(run)
	return _c
}

// AllocSegment provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) AllocSegment(_a0 context.Context, _a1 *datapb.AllocSegmentRequest) (*datapb.AllocSegmentResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// AllocSegment is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.AllocSegmentRequest
func (_e *MockDataCoord_Expecter) AllocSegment(_a0 interface{}, _a1 interface{}) *MockDataCoord_AllocSegment_Call {
	return &MockDataCoord_AllocSegment_Call{Call: _e.mock.On("AllocSegment", _a0, _a1)}
}

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

func (_c *MockDataCoord_AllocSegment_Call) Return(_a0 *datapb.AllocSegmentResponse, _a1 error) *MockDataCoord_AllocSegment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_AllocSegment_Call) RunAndReturn(run func(context.Context, *datapb.AllocSegmentRequest) (*datapb.AllocSegmentResponse, error)) *MockDataCoord_AllocSegment_Call {
	_c.Call.Return(run)
	return _c
}

// AlterIndex provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) AlterIndex(_a0 context.Context, _a1 *indexpb.AlterIndexRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.AlterIndexRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.AlterIndexRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// AlterIndex is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.AlterIndexRequest
func (_e *MockDataCoord_Expecter) AlterIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_AlterIndex_Call {
	return &MockDataCoord_AlterIndex_Call{Call: _e.mock.On("AlterIndex", _a0, _a1)}
}

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

func (_c *MockDataCoord_AlterIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_AlterIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_AlterIndex_Call) RunAndReturn(run func(context.Context, *indexpb.AlterIndexRequest) (*commonpb.Status, error)) *MockDataCoord_AlterIndex_Call {
	_c.Call.Return(run)
	return _c
}

// AssignSegmentID provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) AssignSegmentID(_a0 context.Context, _a1 *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// AssignSegmentID is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.AssignSegmentIDRequest
func (_e *MockDataCoord_Expecter) AssignSegmentID(_a0 interface{}, _a1 interface{}) *MockDataCoord_AssignSegmentID_Call {
	return &MockDataCoord_AssignSegmentID_Call{Call: _e.mock.On("AssignSegmentID", _a0, _a1)}
}

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

func (_c *MockDataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResponse, _a1 error) *MockDataCoord_AssignSegmentID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_AssignSegmentID_Call) RunAndReturn(run func(context.Context, *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error)) *MockDataCoord_AssignSegmentID_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateManifest provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) BatchUpdateManifest(_a0 context.Context, _a1 *datapb.BatchUpdateManifestRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.BatchUpdateManifestRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.BatchUpdateManifestRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// BatchUpdateManifest is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.BatchUpdateManifestRequest
func (_e *MockDataCoord_Expecter) BatchUpdateManifest(_a0 interface{}, _a1 interface{}) *MockDataCoord_BatchUpdateManifest_Call {
	return &MockDataCoord_BatchUpdateManifest_Call{Call: _e.mock.On("BatchUpdateManifest", _a0, _a1)}
}

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

func (_c *MockDataCoord_BatchUpdateManifest_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_BatchUpdateManifest_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_BatchUpdateManifest_Call) RunAndReturn(run func(context.Context, *datapb.BatchUpdateManifestRequest) (*commonpb.Status, error)) *MockDataCoord_BatchUpdateManifest_Call {
	_c.Call.Return(run)
	return _c
}

// BroadcastAlteredCollection provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) BroadcastAlteredCollection(_a0 context.Context, _a1 *datapb.AlterCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// BroadcastAlteredCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.AlterCollectionRequest
func (_e *MockDataCoord_Expecter) BroadcastAlteredCollection(_a0 interface{}, _a1 interface{}) *MockDataCoord_BroadcastAlteredCollection_Call {
	return &MockDataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", _a0, _a1)}
}

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

func (_c *MockDataCoord_BroadcastAlteredCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_BroadcastAlteredCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_BroadcastAlteredCollection_Call) RunAndReturn(run func(context.Context, *datapb.AlterCollectionRequest) (*commonpb.Status, error)) *MockDataCoord_BroadcastAlteredCollection_Call {
	_c.Call.Return(run)
	return _c
}

// CheckHealth provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) CheckHealth(_a0 context.Context, _a1 *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// CheckHealth is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CheckHealthRequest
func (_e *MockDataCoord_Expecter) CheckHealth(_a0 interface{}, _a1 interface{}) *MockDataCoord_CheckHealth_Call {
	return &MockDataCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", _a0, _a1)}
}

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

func (_c *MockDataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *MockDataCoord_CheckHealth_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_CheckHealth_Call) RunAndReturn(run func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)) *MockDataCoord_CheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// CommitBackfillResult provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) CommitBackfillResult(_a0 context.Context, _a1 *datapb.CommitBackfillResultRequest) (*datapb.CommitBackfillResultResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// CommitBackfillResult is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.CommitBackfillResultRequest
func (_e *MockDataCoord_Expecter) CommitBackfillResult(_a0 interface{}, _a1 interface{}) *MockDataCoord_CommitBackfillResult_Call {
	return &MockDataCoord_CommitBackfillResult_Call{Call: _e.mock.On("CommitBackfillResult", _a0, _a1)}
}

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

func (_c *MockDataCoord_CommitBackfillResult_Call) Return(_a0 *datapb.CommitBackfillResultResponse, _a1 error) *MockDataCoord_CommitBackfillResult_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_CommitBackfillResult_Call) RunAndReturn(run func(context.Context, *datapb.CommitBackfillResultRequest) (*datapb.CommitBackfillResultResponse, error)) *MockDataCoord_CommitBackfillResult_Call {
	_c.Call.Return(run)
	return _c
}

// CommitImport provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) CommitImport(_a0 context.Context, _a1 *datapb.CommitImportRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CommitImportRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CommitImportRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// CommitImport is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.CommitImportRequest
func (_e *MockDataCoord_Expecter) CommitImport(_a0 interface{}, _a1 interface{}) *MockDataCoord_CommitImport_Call {
	return &MockDataCoord_CommitImport_Call{Call: _e.mock.On("CommitImport", _a0, _a1)}
}

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

func (_c *MockDataCoord_CommitImport_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_CommitImport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_CommitImport_Call) RunAndReturn(run func(context.Context, *datapb.CommitImportRequest) (*commonpb.Status, error)) *MockDataCoord_CommitImport_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIndex provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) CreateIndex(_a0 context.Context, _a1 *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// CreateIndex is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.CreateIndexRequest
func (_e *MockDataCoord_Expecter) CreateIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_CreateIndex_Call {
	return &MockDataCoord_CreateIndex_Call{Call: _e.mock.On("CreateIndex", _a0, _a1)}
}

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

func (_c *MockDataCoord_CreateIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_CreateIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_CreateIndex_Call) RunAndReturn(run func(context.Context, *indexpb.CreateIndexRequest) (*commonpb.Status, error)) *MockDataCoord_CreateIndex_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) CreateSnapshot(_a0 context.Context, _a1 *datapb.CreateSnapshotRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CreateSnapshotRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CreateSnapshotRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// CreateSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.CreateSnapshotRequest
func (_e *MockDataCoord_Expecter) CreateSnapshot(_a0 interface{}, _a1 interface{}) *MockDataCoord_CreateSnapshot_Call {
	return &MockDataCoord_CreateSnapshot_Call{Call: _e.mock.On("CreateSnapshot", _a0, _a1)}
}

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

func (_c *MockDataCoord_CreateSnapshot_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_CreateSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_CreateSnapshot_Call) RunAndReturn(run func(context.Context, *datapb.CreateSnapshotRequest) (*commonpb.Status, error)) *MockDataCoord_CreateSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIndex provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) DescribeIndex(_a0 context.Context, _a1 *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeIndex is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.DescribeIndexRequest
func (_e *MockDataCoord_Expecter) DescribeIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_DescribeIndex_Call {
	return &MockDataCoord_DescribeIndex_Call{Call: _e.mock.On("DescribeIndex", _a0, _a1)}
}

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

func (_c *MockDataCoord_DescribeIndex_Call) Return(_a0 *indexpb.DescribeIndexResponse, _a1 error) *MockDataCoord_DescribeIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_DescribeIndex_Call) RunAndReturn(run func(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)) *MockDataCoord_DescribeIndex_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) DescribeSnapshot(_a0 context.Context, _a1 *datapb.DescribeSnapshotRequest) (*datapb.DescribeSnapshotResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.DescribeSnapshotRequest
func (_e *MockDataCoord_Expecter) DescribeSnapshot(_a0 interface{}, _a1 interface{}) *MockDataCoord_DescribeSnapshot_Call {
	return &MockDataCoord_DescribeSnapshot_Call{Call: _e.mock.On("DescribeSnapshot", _a0, _a1)}
}

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

func (_c *MockDataCoord_DescribeSnapshot_Call) Return(_a0 *datapb.DescribeSnapshotResponse, _a1 error) *MockDataCoord_DescribeSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_DescribeSnapshot_Call) RunAndReturn(run func(context.Context, *datapb.DescribeSnapshotRequest) (*datapb.DescribeSnapshotResponse, error)) *MockDataCoord_DescribeSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// DropIndex provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) DropIndex(_a0 context.Context, _a1 *indexpb.DropIndexRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// DropIndex is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.DropIndexRequest
func (_e *MockDataCoord_Expecter) DropIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_DropIndex_Call {
	return &MockDataCoord_DropIndex_Call{Call: _e.mock.On("DropIndex", _a0, _a1)}
}

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

func (_c *MockDataCoord_DropIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_DropIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_DropIndex_Call) RunAndReturn(run func(context.Context, *indexpb.DropIndexRequest) (*commonpb.Status, error)) *MockDataCoord_DropIndex_Call {
	_c.Call.Return(run)
	return _c
}

// DropSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) DropSnapshot(_a0 context.Context, _a1 *datapb.DropSnapshotRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropSnapshotRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropSnapshotRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// DropSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.DropSnapshotRequest
func (_e *MockDataCoord_Expecter) DropSnapshot(_a0 interface{}, _a1 interface{}) *MockDataCoord_DropSnapshot_Call {
	return &MockDataCoord_DropSnapshot_Call{Call: _e.mock.On("DropSnapshot", _a0, _a1)}
}

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

func (_c *MockDataCoord_DropSnapshot_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_DropSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_DropSnapshot_Call) RunAndReturn(run func(context.Context, *datapb.DropSnapshotRequest) (*commonpb.Status, error)) *MockDataCoord_DropSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// DropVirtualChannel provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) DropVirtualChannel(_a0 context.Context, _a1 *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DropVirtualChannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.DropVirtualChannelRequest
func (_e *MockDataCoord_Expecter) DropVirtualChannel(_a0 interface{}, _a1 interface{}) *MockDataCoord_DropVirtualChannel_Call {
	return &MockDataCoord_DropVirtualChannel_Call{Call: _e.mock.On("DropVirtualChannel", _a0, _a1)}
}

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

func (_c *MockDataCoord_DropVirtualChannel_Call) Return(_a0 *datapb.DropVirtualChannelResponse, _a1 error) *MockDataCoord_DropVirtualChannel_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_DropVirtualChannel_Call) RunAndReturn(run func(context.Context, *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)) *MockDataCoord_DropVirtualChannel_Call {
	_c.Call.Return(run)
	return _c
}

// ExportSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ExportSnapshot(_a0 context.Context, _a1 *datapb.ExportSnapshotRequest) (*datapb.ExportSnapshotResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ExportSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.ExportSnapshotRequest
func (_e *MockDataCoord_Expecter) ExportSnapshot(_a0 interface{}, _a1 interface{}) *MockDataCoord_ExportSnapshot_Call {
	return &MockDataCoord_ExportSnapshot_Call{Call: _e.mock.On("ExportSnapshot", _a0, _a1)}
}

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

func (_c *MockDataCoord_ExportSnapshot_Call) Return(_a0 *datapb.ExportSnapshotResponse, _a1 error) *MockDataCoord_ExportSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ExportSnapshot_Call) RunAndReturn(run func(context.Context, *datapb.ExportSnapshotRequest) (*datapb.ExportSnapshotResponse, error)) *MockDataCoord_ExportSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// Flush provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) Flush(_a0 context.Context, _a1 *datapb.FlushRequest) (*datapb.FlushResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// Flush is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.FlushRequest
func (_e *MockDataCoord_Expecter) Flush(_a0 interface{}, _a1 interface{}) *MockDataCoord_Flush_Call {
	return &MockDataCoord_Flush_Call{Call: _e.mock.On("Flush", _a0, _a1)}
}

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

func (_c *MockDataCoord_Flush_Call) Return(_a0 *datapb.FlushResponse, _a1 error) *MockDataCoord_Flush_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_Flush_Call) RunAndReturn(run func(context.Context, *datapb.FlushRequest) (*datapb.FlushResponse, error)) *MockDataCoord_Flush_Call {
	_c.Call.Return(run)
	return _c
}

// FlushAll provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) FlushAll(_a0 context.Context, _a1 *datapb.FlushAllRequest) (*datapb.FlushAllResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// FlushAll is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.FlushAllRequest
func (_e *MockDataCoord_Expecter) FlushAll(_a0 interface{}, _a1 interface{}) *MockDataCoord_FlushAll_Call {
	return &MockDataCoord_FlushAll_Call{Call: _e.mock.On("FlushAll", _a0, _a1)}
}

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

func (_c *MockDataCoord_FlushAll_Call) Return(_a0 *datapb.FlushAllResponse, _a1 error) *MockDataCoord_FlushAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_FlushAll_Call) RunAndReturn(run func(context.Context, *datapb.FlushAllRequest) (*datapb.FlushAllResponse, error)) *MockDataCoord_FlushAll_Call {
	_c.Call.Return(run)
	return _c
}

// GcConfirm provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GcConfirm(_a0 context.Context, _a1 *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GcConfirm is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GcConfirmRequest
func (_e *MockDataCoord_Expecter) GcConfirm(_a0 interface{}, _a1 interface{}) *MockDataCoord_GcConfirm_Call {
	return &MockDataCoord_GcConfirm_Call{Call: _e.mock.On("GcConfirm", _a0, _a1)}
}

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

func (_c *MockDataCoord_GcConfirm_Call) Return(_a0 *datapb.GcConfirmResponse, _a1 error) *MockDataCoord_GcConfirm_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GcConfirm_Call) RunAndReturn(run func(context.Context, *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)) *MockDataCoord_GcConfirm_Call {
	_c.Call.Return(run)
	return _c
}

// GcControl provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GcControl(_a0 context.Context, _a1 *datapb.GcControlRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcControlRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcControlRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// GcControl is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GcControlRequest
func (_e *MockDataCoord_Expecter) GcControl(_a0 interface{}, _a1 interface{}) *MockDataCoord_GcControl_Call {
	return &MockDataCoord_GcControl_Call{Call: _e.mock.On("GcControl", _a0, _a1)}
}

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

func (_c *MockDataCoord_GcControl_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_GcControl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GcControl_Call) RunAndReturn(run func(context.Context, *datapb.GcControlRequest) (*commonpb.Status, error)) *MockDataCoord_GcControl_Call {
	_c.Call.Return(run)
	return _c
}

// GetChannelRecoveryInfo provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetChannelRecoveryInfo(_a0 context.Context, _a1 *datapb.GetChannelRecoveryInfoRequest) (*datapb.GetChannelRecoveryInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetChannelRecoveryInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetChannelRecoveryInfoRequest
func (_e *MockDataCoord_Expecter) GetChannelRecoveryInfo(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetChannelRecoveryInfo_Call {
	return &MockDataCoord_GetChannelRecoveryInfo_Call{Call: _e.mock.On("GetChannelRecoveryInfo", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetChannelRecoveryInfo_Call) Return(_a0 *datapb.GetChannelRecoveryInfoResponse, _a1 error) *MockDataCoord_GetChannelRecoveryInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetChannelRecoveryInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetChannelRecoveryInfoRequest) (*datapb.GetChannelRecoveryInfoResponse, error)) *MockDataCoord_GetChannelRecoveryInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetCollectionStatistics provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetCollectionStatistics(_a0 context.Context, _a1 *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetCollectionStatistics is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetCollectionStatisticsRequest
func (_e *MockDataCoord_Expecter) GetCollectionStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetCollectionStatistics_Call {
	return &MockDataCoord_GetCollectionStatistics_Call{Call: _e.mock.On("GetCollectionStatistics", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetCollectionStatistics_Call) Return(_a0 *datapb.GetCollectionStatisticsResponse, _a1 error) *MockDataCoord_GetCollectionStatistics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetCollectionStatistics_Call) RunAndReturn(run func(context.Context, *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error)) *MockDataCoord_GetCollectionStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// GetCompactionState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetCompactionState(_a0 context.Context, _a1 *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetCompactionState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetCompactionStateRequest
func (_e *MockDataCoord_Expecter) GetCompactionState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetCompactionState_Call {
	return &MockDataCoord_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetCompactionState_Call) Return(_a0 *milvuspb.GetCompactionStateResponse, _a1 error) *MockDataCoord_GetCompactionState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetCompactionState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error)) *MockDataCoord_GetCompactionState_Call {
	_c.Call.Return(run)
	return _c
}

// GetCompactionStateWithPlans provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetCompactionStateWithPlans(_a0 context.Context, _a1 *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetCompactionStateWithPlans is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetCompactionPlansRequest
func (_e *MockDataCoord_Expecter) GetCompactionStateWithPlans(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetCompactionStateWithPlans_Call {
	return &MockDataCoord_GetCompactionStateWithPlans_Call{Call: _e.mock.On("GetCompactionStateWithPlans", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) Return(_a0 *milvuspb.GetCompactionPlansResponse, _a1 error) *MockDataCoord_GetCompactionStateWithPlans_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) RunAndReturn(run func(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)) *MockDataCoord_GetCompactionStateWithPlans_Call {
	_c.Call.Return(run)
	return _c
}

// GetFlushAllState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetFlushAllState(_a0 context.Context, _a1 *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetFlushAllState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetFlushAllStateRequest
func (_e *MockDataCoord_Expecter) GetFlushAllState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetFlushAllState_Call {
	return &MockDataCoord_GetFlushAllState_Call{Call: _e.mock.On("GetFlushAllState", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetFlushAllState_Call) Return(_a0 *milvuspb.GetFlushAllStateResponse, _a1 error) *MockDataCoord_GetFlushAllState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetFlushAllState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error)) *MockDataCoord_GetFlushAllState_Call {
	_c.Call.Return(run)
	return _c
}

// GetFlushState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetFlushState(_a0 context.Context, _a1 *datapb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *milvuspb.GetFlushStateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushStateRequest) *milvuspb.GetFlushStateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetFlushStateResponse)
		}
	}

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

	return r0, r1
}

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

// GetFlushState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetFlushStateRequest
func (_e *MockDataCoord_Expecter) GetFlushState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetFlushState_Call {
	return &MockDataCoord_GetFlushState_Call{Call: _e.mock.On("GetFlushState", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetFlushState_Call) Return(_a0 *milvuspb.GetFlushStateResponse, _a1 error) *MockDataCoord_GetFlushState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetFlushState_Call) RunAndReturn(run func(context.Context, *datapb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)) *MockDataCoord_GetFlushState_Call {
	_c.Call.Return(run)
	return _c
}

// GetFlushedSegments provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetFlushedSegments(_a0 context.Context, _a1 *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetFlushedSegments is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetFlushedSegmentsRequest
func (_e *MockDataCoord_Expecter) GetFlushedSegments(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetFlushedSegments_Call {
	return &MockDataCoord_GetFlushedSegments_Call{Call: _e.mock.On("GetFlushedSegments", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetFlushedSegments_Call) Return(_a0 *datapb.GetFlushedSegmentsResponse, _a1 error) *MockDataCoord_GetFlushedSegments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetFlushedSegments_Call) RunAndReturn(run func(context.Context, *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error)) *MockDataCoord_GetFlushedSegments_Call {
	_c.Call.Return(run)
	return _c
}

// GetImportProgress provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetImportProgress(_a0 context.Context, _a1 *internalpb.GetImportProgressRequest) (*internalpb.GetImportProgressResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetImportProgress is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.GetImportProgressRequest
func (_e *MockDataCoord_Expecter) GetImportProgress(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetImportProgress_Call {
	return &MockDataCoord_GetImportProgress_Call{Call: _e.mock.On("GetImportProgress", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetImportProgress_Call) Return(_a0 *internalpb.GetImportProgressResponse, _a1 error) *MockDataCoord_GetImportProgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetImportProgress_Call) RunAndReturn(run func(context.Context, *internalpb.GetImportProgressRequest) (*internalpb.GetImportProgressResponse, error)) *MockDataCoord_GetImportProgress_Call {
	_c.Call.Return(run)
	return _c
}

// GetIndexBuildProgress provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetIndexBuildProgress(_a0 context.Context, _a1 *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetIndexBuildProgress is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.GetIndexBuildProgressRequest
func (_e *MockDataCoord_Expecter) GetIndexBuildProgress(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexBuildProgress_Call {
	return &MockDataCoord_GetIndexBuildProgress_Call{Call: _e.mock.On("GetIndexBuildProgress", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetIndexBuildProgress_Call) Return(_a0 *indexpb.GetIndexBuildProgressResponse, _a1 error) *MockDataCoord_GetIndexBuildProgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetIndexBuildProgress_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)) *MockDataCoord_GetIndexBuildProgress_Call {
	_c.Call.Return(run)
	return _c
}

// GetIndexInfos provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetIndexInfos(_a0 context.Context, _a1 *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetIndexInfos is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.GetIndexInfoRequest
func (_e *MockDataCoord_Expecter) GetIndexInfos(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexInfos_Call {
	return &MockDataCoord_GetIndexInfos_Call{Call: _e.mock.On("GetIndexInfos", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetIndexInfos_Call) Return(_a0 *indexpb.GetIndexInfoResponse, _a1 error) *MockDataCoord_GetIndexInfos_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetIndexInfos_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error)) *MockDataCoord_GetIndexInfos_Call {
	_c.Call.Return(run)
	return _c
}

// GetIndexState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetIndexState(_a0 context.Context, _a1 *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetIndexState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.GetIndexStateRequest
func (_e *MockDataCoord_Expecter) GetIndexState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexState_Call {
	return &MockDataCoord_GetIndexState_Call{Call: _e.mock.On("GetIndexState", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetIndexState_Call) Return(_a0 *indexpb.GetIndexStateResponse, _a1 error) *MockDataCoord_GetIndexState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetIndexState_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)) *MockDataCoord_GetIndexState_Call {
	_c.Call.Return(run)
	return _c
}

// GetIndexStatistics provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetIndexStatistics(_a0 context.Context, _a1 *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetIndexStatistics is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.GetIndexStatisticsRequest
func (_e *MockDataCoord_Expecter) GetIndexStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexStatistics_Call {
	return &MockDataCoord_GetIndexStatistics_Call{Call: _e.mock.On("GetIndexStatistics", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetIndexStatistics_Call) Return(_a0 *indexpb.GetIndexStatisticsResponse, _a1 error) *MockDataCoord_GetIndexStatistics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetIndexStatistics_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error)) *MockDataCoord_GetIndexStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// GetInsertBinlogPaths provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetInsertBinlogPaths(_a0 context.Context, _a1 *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetInsertBinlogPaths is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetInsertBinlogPathsRequest
func (_e *MockDataCoord_Expecter) GetInsertBinlogPaths(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetInsertBinlogPaths_Call {
	return &MockDataCoord_GetInsertBinlogPaths_Call{Call: _e.mock.On("GetInsertBinlogPaths", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetInsertBinlogPaths_Call) Return(_a0 *datapb.GetInsertBinlogPathsResponse, _a1 error) *MockDataCoord_GetInsertBinlogPaths_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetInsertBinlogPaths_Call) RunAndReturn(run func(context.Context, *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error)) *MockDataCoord_GetInsertBinlogPaths_Call {
	_c.Call.Return(run)
	return _c
}

// GetMetrics provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetMetrics(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetMetrics is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetMetricsRequest
func (_e *MockDataCoord_Expecter) GetMetrics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetMetrics_Call {
	return &MockDataCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse, _a1 error) *MockDataCoord_GetMetrics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetMetrics_Call) RunAndReturn(run func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)) *MockDataCoord_GetMetrics_Call {
	_c.Call.Return(run)
	return _c
}

// GetPartitionStatistics provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetPartitionStatistics(_a0 context.Context, _a1 *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetPartitionStatistics is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetPartitionStatisticsRequest
func (_e *MockDataCoord_Expecter) GetPartitionStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetPartitionStatistics_Call {
	return &MockDataCoord_GetPartitionStatistics_Call{Call: _e.mock.On("GetPartitionStatistics", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetPartitionStatistics_Call) Return(_a0 *datapb.GetPartitionStatisticsResponse, _a1 error) *MockDataCoord_GetPartitionStatistics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetPartitionStatistics_Call) RunAndReturn(run func(context.Context, *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error)) *MockDataCoord_GetPartitionStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// GetRecoveryInfo provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetRecoveryInfo(_a0 context.Context, _a1 *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetRecoveryInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetRecoveryInfoRequest
func (_e *MockDataCoord_Expecter) GetRecoveryInfo(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetRecoveryInfo_Call {
	return &MockDataCoord_GetRecoveryInfo_Call{Call: _e.mock.On("GetRecoveryInfo", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetRecoveryInfo_Call) Return(_a0 *datapb.GetRecoveryInfoResponse, _a1 error) *MockDataCoord_GetRecoveryInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetRecoveryInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error)) *MockDataCoord_GetRecoveryInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetRecoveryInfoV2 provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetRecoveryInfoV2(_a0 context.Context, _a1 *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetRecoveryInfoV2 is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetRecoveryInfoRequestV2
func (_e *MockDataCoord_Expecter) GetRecoveryInfoV2(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetRecoveryInfoV2_Call {
	return &MockDataCoord_GetRecoveryInfoV2_Call{Call: _e.mock.On("GetRecoveryInfoV2", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetRecoveryInfoV2_Call) Return(_a0 *datapb.GetRecoveryInfoResponseV2, _a1 error) *MockDataCoord_GetRecoveryInfoV2_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetRecoveryInfoV2_Call) RunAndReturn(run func(context.Context, *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error)) *MockDataCoord_GetRecoveryInfoV2_Call {
	_c.Call.Return(run)
	return _c
}

// GetRefreshExternalCollectionProgress provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetRefreshExternalCollectionProgress(_a0 context.Context, _a1 *datapb.GetRefreshExternalCollectionProgressRequest) (*datapb.GetRefreshExternalCollectionProgressResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetRefreshExternalCollectionProgress is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetRefreshExternalCollectionProgressRequest
func (_e *MockDataCoord_Expecter) GetRefreshExternalCollectionProgress(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetRefreshExternalCollectionProgress_Call {
	return &MockDataCoord_GetRefreshExternalCollectionProgress_Call{Call: _e.mock.On("GetRefreshExternalCollectionProgress", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetRefreshExternalCollectionProgress_Call) Return(_a0 *datapb.GetRefreshExternalCollectionProgressResponse, _a1 error) *MockDataCoord_GetRefreshExternalCollectionProgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetRefreshExternalCollectionProgress_Call) RunAndReturn(run func(context.Context, *datapb.GetRefreshExternalCollectionProgressRequest) (*datapb.GetRefreshExternalCollectionProgressResponse, error)) *MockDataCoord_GetRefreshExternalCollectionProgress_Call {
	_c.Call.Return(run)
	return _c
}

// GetRestoreSnapshotState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetRestoreSnapshotState(_a0 context.Context, _a1 *datapb.GetRestoreSnapshotStateRequest) (*datapb.GetRestoreSnapshotStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetRestoreSnapshotState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetRestoreSnapshotStateRequest
func (_e *MockDataCoord_Expecter) GetRestoreSnapshotState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetRestoreSnapshotState_Call {
	return &MockDataCoord_GetRestoreSnapshotState_Call{Call: _e.mock.On("GetRestoreSnapshotState", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetRestoreSnapshotState_Call) Return(_a0 *datapb.GetRestoreSnapshotStateResponse, _a1 error) *MockDataCoord_GetRestoreSnapshotState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetRestoreSnapshotState_Call) RunAndReturn(run func(context.Context, *datapb.GetRestoreSnapshotStateRequest) (*datapb.GetRestoreSnapshotStateResponse, error)) *MockDataCoord_GetRestoreSnapshotState_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentIndexState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetSegmentIndexState(_a0 context.Context, _a1 *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetSegmentIndexState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.GetSegmentIndexStateRequest
func (_e *MockDataCoord_Expecter) GetSegmentIndexState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentIndexState_Call {
	return &MockDataCoord_GetSegmentIndexState_Call{Call: _e.mock.On("GetSegmentIndexState", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetSegmentIndexState_Call) Return(_a0 *indexpb.GetSegmentIndexStateResponse, _a1 error) *MockDataCoord_GetSegmentIndexState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetSegmentIndexState_Call) RunAndReturn(run func(context.Context, *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error)) *MockDataCoord_GetSegmentIndexState_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentInfo provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetSegmentInfo(_a0 context.Context, _a1 *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetSegmentInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetSegmentInfoRequest
func (_e *MockDataCoord_Expecter) GetSegmentInfo(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentInfo_Call {
	return &MockDataCoord_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetSegmentInfo_Call) Return(_a0 *datapb.GetSegmentInfoResponse, _a1 error) *MockDataCoord_GetSegmentInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetSegmentInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error)) *MockDataCoord_GetSegmentInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentInfoChannel provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetSegmentInfoChannel(_a0 context.Context, _a1 *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *milvuspb.StringResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoChannelRequest) *milvuspb.StringResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.StringResponse)
		}
	}

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

	return r0, r1
}

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

// GetSegmentInfoChannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetSegmentInfoChannelRequest
func (_e *MockDataCoord_Expecter) GetSegmentInfoChannel(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentInfoChannel_Call {
	return &MockDataCoord_GetSegmentInfoChannel_Call{Call: _e.mock.On("GetSegmentInfoChannel", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetSegmentInfoChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *MockDataCoord_GetSegmentInfoChannel_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetSegmentInfoChannel_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error)) *MockDataCoord_GetSegmentInfoChannel_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentStates provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetSegmentStates(_a0 context.Context, _a1 *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetSegmentStates is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetSegmentStatesRequest
func (_e *MockDataCoord_Expecter) GetSegmentStates(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentStates_Call {
	return &MockDataCoord_GetSegmentStates_Call{Call: _e.mock.On("GetSegmentStates", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetSegmentStates_Call) Return(_a0 *datapb.GetSegmentStatesResponse, _a1 error) *MockDataCoord_GetSegmentStates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetSegmentStates_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)) *MockDataCoord_GetSegmentStates_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentsByStates provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) GetSegmentsByStates(_a0 context.Context, _a1 *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetSegmentsByStates is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.GetSegmentsByStatesRequest
func (_e *MockDataCoord_Expecter) GetSegmentsByStates(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentsByStates_Call {
	return &MockDataCoord_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates", _a0, _a1)}
}

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

func (_c *MockDataCoord_GetSegmentsByStates_Call) Return(_a0 *datapb.GetSegmentsByStatesResponse, _a1 error) *MockDataCoord_GetSegmentsByStates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_GetSegmentsByStates_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error)) *MockDataCoord_GetSegmentsByStates_Call {
	_c.Call.Return(run)
	return _c
}

// HandleCommitVchannel provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) HandleCommitVchannel(_a0 context.Context, _a1 *datapb.HandleCommitVchannelRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.HandleCommitVchannelRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.HandleCommitVchannelRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// HandleCommitVchannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.HandleCommitVchannelRequest
func (_e *MockDataCoord_Expecter) HandleCommitVchannel(_a0 interface{}, _a1 interface{}) *MockDataCoord_HandleCommitVchannel_Call {
	return &MockDataCoord_HandleCommitVchannel_Call{Call: _e.mock.On("HandleCommitVchannel", _a0, _a1)}
}

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

func (_c *MockDataCoord_HandleCommitVchannel_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_HandleCommitVchannel_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_HandleCommitVchannel_Call) RunAndReturn(run func(context.Context, *datapb.HandleCommitVchannelRequest) (*commonpb.Status, error)) *MockDataCoord_HandleCommitVchannel_Call {
	_c.Call.Return(run)
	return _c
}

// ImportV2 provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ImportV2(_a0 context.Context, _a1 *internalpb.ImportRequestInternal) (*internalpb.ImportResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ImportV2 is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.ImportRequestInternal
func (_e *MockDataCoord_Expecter) ImportV2(_a0 interface{}, _a1 interface{}) *MockDataCoord_ImportV2_Call {
	return &MockDataCoord_ImportV2_Call{Call: _e.mock.On("ImportV2", _a0, _a1)}
}

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

func (_c *MockDataCoord_ImportV2_Call) Return(_a0 *internalpb.ImportResponse, _a1 error) *MockDataCoord_ImportV2_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ImportV2_Call) RunAndReturn(run func(context.Context, *internalpb.ImportRequestInternal) (*internalpb.ImportResponse, error)) *MockDataCoord_ImportV2_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Init is a helper method to define mock.On call
func (_e *MockDataCoord_Expecter) Init() *MockDataCoord_Init_Call {
	return &MockDataCoord_Init_Call{Call: _e.mock.On("Init")}
}

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

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

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

// ListImports provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ListImports(_a0 context.Context, _a1 *internalpb.ListImportsRequestInternal) (*internalpb.ListImportsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListImports is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.ListImportsRequestInternal
func (_e *MockDataCoord_Expecter) ListImports(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListImports_Call {
	return &MockDataCoord_ListImports_Call{Call: _e.mock.On("ListImports", _a0, _a1)}
}

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

func (_c *MockDataCoord_ListImports_Call) Return(_a0 *internalpb.ListImportsResponse, _a1 error) *MockDataCoord_ListImports_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ListImports_Call) RunAndReturn(run func(context.Context, *internalpb.ListImportsRequestInternal) (*internalpb.ListImportsResponse, error)) *MockDataCoord_ListImports_Call {
	_c.Call.Return(run)
	return _c
}

// ListIndexes provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ListIndexes(_a0 context.Context, _a1 *indexpb.ListIndexesRequest) (*indexpb.ListIndexesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListIndexes is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *indexpb.ListIndexesRequest
func (_e *MockDataCoord_Expecter) ListIndexes(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListIndexes_Call {
	return &MockDataCoord_ListIndexes_Call{Call: _e.mock.On("ListIndexes", _a0, _a1)}
}

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

func (_c *MockDataCoord_ListIndexes_Call) Return(_a0 *indexpb.ListIndexesResponse, _a1 error) *MockDataCoord_ListIndexes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ListIndexes_Call) RunAndReturn(run func(context.Context, *indexpb.ListIndexesRequest) (*indexpb.ListIndexesResponse, error)) *MockDataCoord_ListIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// ListRefreshExternalCollectionJobs provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ListRefreshExternalCollectionJobs(_a0 context.Context, _a1 *datapb.ListRefreshExternalCollectionJobsRequest) (*datapb.ListRefreshExternalCollectionJobsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListRefreshExternalCollectionJobs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.ListRefreshExternalCollectionJobsRequest
func (_e *MockDataCoord_Expecter) ListRefreshExternalCollectionJobs(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListRefreshExternalCollectionJobs_Call {
	return &MockDataCoord_ListRefreshExternalCollectionJobs_Call{Call: _e.mock.On("ListRefreshExternalCollectionJobs", _a0, _a1)}
}

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

func (_c *MockDataCoord_ListRefreshExternalCollectionJobs_Call) Return(_a0 *datapb.ListRefreshExternalCollectionJobsResponse, _a1 error) *MockDataCoord_ListRefreshExternalCollectionJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ListRefreshExternalCollectionJobs_Call) RunAndReturn(run func(context.Context, *datapb.ListRefreshExternalCollectionJobsRequest) (*datapb.ListRefreshExternalCollectionJobsResponse, error)) *MockDataCoord_ListRefreshExternalCollectionJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListRestoreSnapshotJobs provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ListRestoreSnapshotJobs(_a0 context.Context, _a1 *datapb.ListRestoreSnapshotJobsRequest) (*datapb.ListRestoreSnapshotJobsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListRestoreSnapshotJobs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.ListRestoreSnapshotJobsRequest
func (_e *MockDataCoord_Expecter) ListRestoreSnapshotJobs(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListRestoreSnapshotJobs_Call {
	return &MockDataCoord_ListRestoreSnapshotJobs_Call{Call: _e.mock.On("ListRestoreSnapshotJobs", _a0, _a1)}
}

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

func (_c *MockDataCoord_ListRestoreSnapshotJobs_Call) Return(_a0 *datapb.ListRestoreSnapshotJobsResponse, _a1 error) *MockDataCoord_ListRestoreSnapshotJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ListRestoreSnapshotJobs_Call) RunAndReturn(run func(context.Context, *datapb.ListRestoreSnapshotJobsRequest) (*datapb.ListRestoreSnapshotJobsResponse, error)) *MockDataCoord_ListRestoreSnapshotJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListSnapshots provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ListSnapshots(_a0 context.Context, _a1 *datapb.ListSnapshotsRequest) (*datapb.ListSnapshotsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListSnapshots is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.ListSnapshotsRequest
func (_e *MockDataCoord_Expecter) ListSnapshots(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListSnapshots_Call {
	return &MockDataCoord_ListSnapshots_Call{Call: _e.mock.On("ListSnapshots", _a0, _a1)}
}

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

func (_c *MockDataCoord_ListSnapshots_Call) Return(_a0 *datapb.ListSnapshotsResponse, _a1 error) *MockDataCoord_ListSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ListSnapshots_Call) RunAndReturn(run func(context.Context, *datapb.ListSnapshotsRequest) (*datapb.ListSnapshotsResponse, error)) *MockDataCoord_ListSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// ManualCompaction provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ManualCompaction(_a0 context.Context, _a1 *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ManualCompaction is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ManualCompactionRequest
func (_e *MockDataCoord_Expecter) ManualCompaction(_a0 interface{}, _a1 interface{}) *MockDataCoord_ManualCompaction_Call {
	return &MockDataCoord_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction", _a0, _a1)}
}

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

func (_c *MockDataCoord_ManualCompaction_Call) Return(_a0 *milvuspb.ManualCompactionResponse, _a1 error) *MockDataCoord_ManualCompaction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ManualCompaction_Call) RunAndReturn(run func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)) *MockDataCoord_ManualCompaction_Call {
	_c.Call.Return(run)
	return _c
}

// MarkSegmentsDropped provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) MarkSegmentsDropped(_a0 context.Context, _a1 *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// MarkSegmentsDropped is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.MarkSegmentsDroppedRequest
func (_e *MockDataCoord_Expecter) MarkSegmentsDropped(_a0 interface{}, _a1 interface{}) *MockDataCoord_MarkSegmentsDropped_Call {
	return &MockDataCoord_MarkSegmentsDropped_Call{Call: _e.mock.On("MarkSegmentsDropped", _a0, _a1)}
}

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

func (_c *MockDataCoord_MarkSegmentsDropped_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_MarkSegmentsDropped_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_MarkSegmentsDropped_Call) RunAndReturn(run func(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)) *MockDataCoord_MarkSegmentsDropped_Call {
	_c.Call.Return(run)
	return _c
}

// PinSnapshotData provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) PinSnapshotData(_a0 context.Context, _a1 *datapb.PinSnapshotDataRequest) (*datapb.PinSnapshotDataResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// PinSnapshotData is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.PinSnapshotDataRequest
func (_e *MockDataCoord_Expecter) PinSnapshotData(_a0 interface{}, _a1 interface{}) *MockDataCoord_PinSnapshotData_Call {
	return &MockDataCoord_PinSnapshotData_Call{Call: _e.mock.On("PinSnapshotData", _a0, _a1)}
}

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

func (_c *MockDataCoord_PinSnapshotData_Call) Return(_a0 *datapb.PinSnapshotDataResponse, _a1 error) *MockDataCoord_PinSnapshotData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_PinSnapshotData_Call) RunAndReturn(run func(context.Context, *datapb.PinSnapshotDataRequest) (*datapb.PinSnapshotDataResponse, error)) *MockDataCoord_PinSnapshotData_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshExternalCollection provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) RefreshExternalCollection(_a0 context.Context, _a1 *datapb.RefreshExternalCollectionRequest) (*datapb.RefreshExternalCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// RefreshExternalCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.RefreshExternalCollectionRequest
func (_e *MockDataCoord_Expecter) RefreshExternalCollection(_a0 interface{}, _a1 interface{}) *MockDataCoord_RefreshExternalCollection_Call {
	return &MockDataCoord_RefreshExternalCollection_Call{Call: _e.mock.On("RefreshExternalCollection", _a0, _a1)}
}

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

func (_c *MockDataCoord_RefreshExternalCollection_Call) Return(_a0 *datapb.RefreshExternalCollectionResponse, _a1 error) *MockDataCoord_RefreshExternalCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_RefreshExternalCollection_Call) RunAndReturn(run func(context.Context, *datapb.RefreshExternalCollectionRequest) (*datapb.RefreshExternalCollectionResponse, error)) *MockDataCoord_RefreshExternalCollection_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Register is a helper method to define mock.On call
func (_e *MockDataCoord_Expecter) Register() *MockDataCoord_Register_Call {
	return &MockDataCoord_Register_Call{Call: _e.mock.On("Register")}
}

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

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

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

// ReportDataNodeTtMsgs provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ReportDataNodeTtMsgs(_a0 context.Context, _a1 *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// ReportDataNodeTtMsgs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.ReportDataNodeTtMsgsRequest
func (_e *MockDataCoord_Expecter) ReportDataNodeTtMsgs(_a0 interface{}, _a1 interface{}) *MockDataCoord_ReportDataNodeTtMsgs_Call {
	return &MockDataCoord_ReportDataNodeTtMsgs_Call{Call: _e.mock.On("ReportDataNodeTtMsgs", _a0, _a1)}
}

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

func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_ReportDataNodeTtMsgs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) RunAndReturn(run func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error)) *MockDataCoord_ReportDataNodeTtMsgs_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) RestoreSnapshot(_a0 context.Context, _a1 *datapb.RestoreSnapshotRequest) (*datapb.RestoreSnapshotResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// RestoreSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.RestoreSnapshotRequest
func (_e *MockDataCoord_Expecter) RestoreSnapshot(_a0 interface{}, _a1 interface{}) *MockDataCoord_RestoreSnapshot_Call {
	return &MockDataCoord_RestoreSnapshot_Call{Call: _e.mock.On("RestoreSnapshot", _a0, _a1)}
}

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

func (_c *MockDataCoord_RestoreSnapshot_Call) Return(_a0 *datapb.RestoreSnapshotResponse, _a1 error) *MockDataCoord_RestoreSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_RestoreSnapshot_Call) RunAndReturn(run func(context.Context, *datapb.RestoreSnapshotRequest) (*datapb.RestoreSnapshotResponse, error)) *MockDataCoord_RestoreSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// SaveBinlogPaths provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) SaveBinlogPaths(_a0 context.Context, _a1 *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// SaveBinlogPaths is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.SaveBinlogPathsRequest
func (_e *MockDataCoord_Expecter) SaveBinlogPaths(_a0 interface{}, _a1 interface{}) *MockDataCoord_SaveBinlogPaths_Call {
	return &MockDataCoord_SaveBinlogPaths_Call{Call: _e.mock.On("SaveBinlogPaths", _a0, _a1)}
}

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

func (_c *MockDataCoord_SaveBinlogPaths_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_SaveBinlogPaths_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_SaveBinlogPaths_Call) RunAndReturn(run func(context.Context, *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error)) *MockDataCoord_SaveBinlogPaths_Call {
	_c.Call.Return(run)
	return _c
}

// SetAddress provides a mock function with given fields: address
func (_m *MockDataCoord) SetAddress(address string) {
	_m.Called(address)
}

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

// SetAddress is a helper method to define mock.On call
//   - address string
func (_e *MockDataCoord_Expecter) SetAddress(address interface{}) *MockDataCoord_SetAddress_Call {
	return &MockDataCoord_SetAddress_Call{Call: _e.mock.On("SetAddress", address)}
}

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

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

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

// SetDataNodeCreator provides a mock function with given fields: _a0
func (_m *MockDataCoord) SetDataNodeCreator(_a0 func(context.Context, string, int64) (types.DataNodeClient, error)) {
	_m.Called(_a0)
}

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

// SetDataNodeCreator is a helper method to define mock.On call
//   - _a0 func(context.Context , string , int64)(types.DataNodeClient , error)
func (_e *MockDataCoord_Expecter) SetDataNodeCreator(_a0 interface{}) *MockDataCoord_SetDataNodeCreator_Call {
	return &MockDataCoord_SetDataNodeCreator_Call{Call: _e.mock.On("SetDataNodeCreator", _a0)}
}

func (_c *MockDataCoord_SetDataNodeCreator_Call) Run(run func(_a0 func(context.Context, string, int64) (types.DataNodeClient, error))) *MockDataCoord_SetDataNodeCreator_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, string, int64) (types.DataNodeClient, error)))
	})
	return _c
}

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

func (_c *MockDataCoord_SetDataNodeCreator_Call) RunAndReturn(run func(func(context.Context, string, int64) (types.DataNodeClient, error))) *MockDataCoord_SetDataNodeCreator_Call {
	_c.Run(run)
	return _c
}

// SetEtcdClient provides a mock function with given fields: etcdClient
func (_m *MockDataCoord) SetEtcdClient(etcdClient *clientv3.Client) {
	_m.Called(etcdClient)
}

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

// SetEtcdClient is a helper method to define mock.On call
//   - etcdClient *clientv3.Client
func (_e *MockDataCoord_Expecter) SetEtcdClient(etcdClient interface{}) *MockDataCoord_SetEtcdClient_Call {
	return &MockDataCoord_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)}
}

func (_c *MockDataCoord_SetEtcdClient_Call) Run(run func(etcdClient *clientv3.Client)) *MockDataCoord_SetEtcdClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*clientv3.Client))
	})
	return _c
}

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

func (_c *MockDataCoord_SetEtcdClient_Call) RunAndReturn(run func(*clientv3.Client)) *MockDataCoord_SetEtcdClient_Call {
	_c.Run(run)
	return _c
}

// SetMixCoord provides a mock function with given fields: mixCoord
func (_m *MockDataCoord) SetMixCoord(mixCoord types.MixCoord) {
	_m.Called(mixCoord)
}

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

// SetMixCoord is a helper method to define mock.On call
//   - mixCoord types.MixCoord
func (_e *MockDataCoord_Expecter) SetMixCoord(mixCoord interface{}) *MockDataCoord_SetMixCoord_Call {
	return &MockDataCoord_SetMixCoord_Call{Call: _e.mock.On("SetMixCoord", mixCoord)}
}

func (_c *MockDataCoord_SetMixCoord_Call) Run(run func(mixCoord types.MixCoord)) *MockDataCoord_SetMixCoord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(types.MixCoord))
	})
	return _c
}

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

func (_c *MockDataCoord_SetMixCoord_Call) RunAndReturn(run func(types.MixCoord)) *MockDataCoord_SetMixCoord_Call {
	_c.Run(run)
	return _c
}

// SetSegmentState provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) SetSegmentState(_a0 context.Context, _a1 *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// SetSegmentState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.SetSegmentStateRequest
func (_e *MockDataCoord_Expecter) SetSegmentState(_a0 interface{}, _a1 interface{}) *MockDataCoord_SetSegmentState_Call {
	return &MockDataCoord_SetSegmentState_Call{Call: _e.mock.On("SetSegmentState", _a0, _a1)}
}

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

func (_c *MockDataCoord_SetSegmentState_Call) Return(_a0 *datapb.SetSegmentStateResponse, _a1 error) *MockDataCoord_SetSegmentState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_SetSegmentState_Call) RunAndReturn(run func(context.Context, *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error)) *MockDataCoord_SetSegmentState_Call {
	_c.Call.Return(run)
	return _c
}

// SetTiKVClient provides a mock function with given fields: client
func (_m *MockDataCoord) SetTiKVClient(client *txnkv.Client) {
	_m.Called(client)
}

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

// SetTiKVClient is a helper method to define mock.On call
//   - client *txnkv.Client
func (_e *MockDataCoord_Expecter) SetTiKVClient(client interface{}) *MockDataCoord_SetTiKVClient_Call {
	return &MockDataCoord_SetTiKVClient_Call{Call: _e.mock.On("SetTiKVClient", client)}
}

func (_c *MockDataCoord_SetTiKVClient_Call) Run(run func(client *txnkv.Client)) *MockDataCoord_SetTiKVClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*txnkv.Client))
	})
	return _c
}

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

func (_c *MockDataCoord_SetTiKVClient_Call) RunAndReturn(run func(*txnkv.Client)) *MockDataCoord_SetTiKVClient_Call {
	_c.Run(run)
	return _c
}

// ShowConfigurations provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) ShowConfigurations(_a0 context.Context, _a1 *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowConfigurations is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.ShowConfigurationsRequest
func (_e *MockDataCoord_Expecter) ShowConfigurations(_a0 interface{}, _a1 interface{}) *MockDataCoord_ShowConfigurations_Call {
	return &MockDataCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", _a0, _a1)}
}

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

func (_c *MockDataCoord_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConfigurationsResponse, _a1 error) *MockDataCoord_ShowConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_ShowConfigurations_Call) RunAndReturn(run func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)) *MockDataCoord_ShowConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

	return r0
}

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

// Stop is a helper method to define mock.On call
func (_e *MockDataCoord_Expecter) Stop() *MockDataCoord_Stop_Call {
	return &MockDataCoord_Stop_Call{Call: _e.mock.On("Stop")}
}

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

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

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

// UnpinSnapshotData provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) UnpinSnapshotData(_a0 context.Context, _a1 *datapb.UnpinSnapshotDataRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UnpinSnapshotDataRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UnpinSnapshotDataRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// UnpinSnapshotData is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.UnpinSnapshotDataRequest
func (_e *MockDataCoord_Expecter) UnpinSnapshotData(_a0 interface{}, _a1 interface{}) *MockDataCoord_UnpinSnapshotData_Call {
	return &MockDataCoord_UnpinSnapshotData_Call{Call: _e.mock.On("UnpinSnapshotData", _a0, _a1)}
}

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

func (_c *MockDataCoord_UnpinSnapshotData_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UnpinSnapshotData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_UnpinSnapshotData_Call) RunAndReturn(run func(context.Context, *datapb.UnpinSnapshotDataRequest) (*commonpb.Status, error)) *MockDataCoord_UnpinSnapshotData_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannelCheckpoint provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) UpdateChannelCheckpoint(_a0 context.Context, _a1 *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// UpdateChannelCheckpoint is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.UpdateChannelCheckpointRequest
func (_e *MockDataCoord_Expecter) UpdateChannelCheckpoint(_a0 interface{}, _a1 interface{}) *MockDataCoord_UpdateChannelCheckpoint_Call {
	return &MockDataCoord_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint", _a0, _a1)}
}

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

func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UpdateChannelCheckpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) RunAndReturn(run func(context.Context, *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error)) *MockDataCoord_UpdateChannelCheckpoint_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSegmentStatistics provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) UpdateSegmentStatistics(_a0 context.Context, _a1 *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

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

	return r0, r1
}

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

// UpdateSegmentStatistics is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.UpdateSegmentStatisticsRequest
func (_e *MockDataCoord_Expecter) UpdateSegmentStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_UpdateSegmentStatistics_Call {
	return &MockDataCoord_UpdateSegmentStatistics_Call{Call: _e.mock.On("UpdateSegmentStatistics", _a0, _a1)}
}

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

func (_c *MockDataCoord_UpdateSegmentStatistics_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UpdateSegmentStatistics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_UpdateSegmentStatistics_Call) RunAndReturn(run func(context.Context, *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error)) *MockDataCoord_UpdateSegmentStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// WatchChannels provides a mock function with given fields: _a0, _a1
func (_m *MockDataCoord) WatchChannels(_a0 context.Context, _a1 *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// WatchChannels is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *datapb.WatchChannelsRequest
func (_e *MockDataCoord_Expecter) WatchChannels(_a0 interface{}, _a1 interface{}) *MockDataCoord_WatchChannels_Call {
	return &MockDataCoord_WatchChannels_Call{Call: _e.mock.On("WatchChannels", _a0, _a1)}
}

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

func (_c *MockDataCoord_WatchChannels_Call) Return(_a0 *datapb.WatchChannelsResponse, _a1 error) *MockDataCoord_WatchChannels_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDataCoord_WatchChannels_Call) RunAndReturn(run func(context.Context, *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)) *MockDataCoord_WatchChannels_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
