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

package mocks

import (
	context "context"

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

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

	grpc "google.golang.org/grpc"

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

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

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

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

	msgpb "github.com/milvus-io/milvus-proto/go-api/v2/msgpb"

	proxypb "github.com/milvus-io/milvus/pkg/v2/proto/proxypb"

	querypb "github.com/milvus-io/milvus/pkg/v2/proto/querypb"

	rootcoordpb "github.com/milvus-io/milvus/pkg/v2/proto/rootcoordpb"

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

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

// MixCoord is an autogenerated mock type for the MixCoordComponent type
type MixCoord struct {
	mock.Mock
}

type MixCoord_Expecter struct {
	mock *mock.Mock
}

func (_m *MixCoord) EXPECT() *MixCoord_Expecter {
	return &MixCoord_Expecter{mock: &_m.Mock}
}

// ActivateChecker provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ActivateChecker(_a0 context.Context, _a1 *querypb.ActivateCheckerRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ActivateCheckerRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ActivateCheckerRequest) *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, *querypb.ActivateCheckerRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ActivateChecker is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ActivateCheckerRequest
func (_e *MixCoord_Expecter) ActivateChecker(_a0 interface{}, _a1 interface{}) *MixCoord_ActivateChecker_Call {
	return &MixCoord_ActivateChecker_Call{Call: _e.mock.On("ActivateChecker", _a0, _a1)}
}

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

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

func (_c *MixCoord_ActivateChecker_Call) RunAndReturn(run func(context.Context, *querypb.ActivateCheckerRequest) (*commonpb.Status, error)) *MixCoord_ActivateChecker_Call {
	_c.Call.Return(run)
	return _c
}

// AddCollectionField provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AddCollectionField(_a0 context.Context, _a1 *milvuspb.AddCollectionFieldRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFieldRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFieldRequest) *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, *milvuspb.AddCollectionFieldRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddCollectionField is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AddCollectionFieldRequest
func (_e *MixCoord_Expecter) AddCollectionField(_a0 interface{}, _a1 interface{}) *MixCoord_AddCollectionField_Call {
	return &MixCoord_AddCollectionField_Call{Call: _e.mock.On("AddCollectionField", _a0, _a1)}
}

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

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

func (_c *MixCoord_AddCollectionField_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFieldRequest) (*commonpb.Status, error)) *MixCoord_AddCollectionField_Call {
	_c.Call.Return(run)
	return _c
}

// AddCollectionFunction provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AddCollectionFunction(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) *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, *milvuspb.AddCollectionFunctionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddCollectionFunction is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AddCollectionFunctionRequest
func (_e *MixCoord_Expecter) AddCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_AddCollectionFunction_Call {
	return &MixCoord_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", _a0, _a1)}
}

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

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

func (_c *MixCoord_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_AddCollectionFunction_Call {
	_c.Call.Return(run)
	return _c
}

// AddFileResource provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AddFileResource(_a0 context.Context, _a1 *milvuspb.AddFileResourceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddFileResourceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddFileResourceRequest) *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, *milvuspb.AddFileResourceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddFileResource is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AddFileResourceRequest
func (_e *MixCoord_Expecter) AddFileResource(_a0 interface{}, _a1 interface{}) *MixCoord_AddFileResource_Call {
	return &MixCoord_AddFileResource_Call{Call: _e.mock.On("AddFileResource", _a0, _a1)}
}

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

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

func (_c *MixCoord_AddFileResource_Call) RunAndReturn(run func(context.Context, *milvuspb.AddFileResourceRequest) (*commonpb.Status, error)) *MixCoord_AddFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// AllocID provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AllocID(_a0 context.Context, _a1 *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// AllocID is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.AllocIDRequest
func (_e *MixCoord_Expecter) AllocID(_a0 interface{}, _a1 interface{}) *MixCoord_AllocID_Call {
	return &MixCoord_AllocID_Call{Call: _e.mock.On("AllocID", _a0, _a1)}
}

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

func (_c *MixCoord_AllocID_Call) Return(_a0 *rootcoordpb.AllocIDResponse, _a1 error) *MixCoord_AllocID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_AllocID_Call) RunAndReturn(run func(context.Context, *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error)) *MixCoord_AllocID_Call {
	_c.Call.Return(run)
	return _c
}

// AllocSegment provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// AllocTimestamp provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AllocTimestamp(_a0 context.Context, _a1 *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// AllocTimestamp is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.AllocTimestampRequest
func (_e *MixCoord_Expecter) AllocTimestamp(_a0 interface{}, _a1 interface{}) *MixCoord_AllocTimestamp_Call {
	return &MixCoord_AllocTimestamp_Call{Call: _e.mock.On("AllocTimestamp", _a0, _a1)}
}

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

func (_c *MixCoord_AllocTimestamp_Call) Return(_a0 *rootcoordpb.AllocTimestampResponse, _a1 error) *MixCoord_AllocTimestamp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_AllocTimestamp_Call) RunAndReturn(run func(context.Context, *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error)) *MixCoord_AllocTimestamp_Call {
	_c.Call.Return(run)
	return _c
}

// AlterAlias provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AlterAlias(_a0 context.Context, _a1 *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterAliasRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterAliasRequest) *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, *milvuspb.AlterAliasRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterAlias is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AlterAliasRequest
func (_e *MixCoord_Expecter) AlterAlias(_a0 interface{}, _a1 interface{}) *MixCoord_AlterAlias_Call {
	return &MixCoord_AlterAlias_Call{Call: _e.mock.On("AlterAlias", _a0, _a1)}
}

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

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

func (_c *MixCoord_AlterAlias_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterAliasRequest) (*commonpb.Status, error)) *MixCoord_AlterAlias_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.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, *milvuspb.AlterCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AlterCollectionRequest
func (_e *MixCoord_Expecter) AlterCollection(_a0 interface{}, _a1 interface{}) *MixCoord_AlterCollection_Call {
	return &MixCoord_AlterCollection_Call{Call: _e.mock.On("AlterCollection", _a0, _a1)}
}

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

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

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

// AlterCollectionField provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AlterCollectionField(_a0 context.Context, _a1 *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFieldRequest) *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, *milvuspb.AlterCollectionFieldRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterCollectionField is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AlterCollectionFieldRequest
func (_e *MixCoord_Expecter) AlterCollectionField(_a0 interface{}, _a1 interface{}) *MixCoord_AlterCollectionField_Call {
	return &MixCoord_AlterCollectionField_Call{Call: _e.mock.On("AlterCollectionField", _a0, _a1)}
}

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

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

func (_c *MixCoord_AlterCollectionField_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error)) *MixCoord_AlterCollectionField_Call {
	_c.Call.Return(run)
	return _c
}

// AlterCollectionFunction provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AlterCollectionFunction(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) *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, *milvuspb.AlterCollectionFunctionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterCollectionFunction is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AlterCollectionFunctionRequest
func (_e *MixCoord_Expecter) AlterCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_AlterCollectionFunction_Call {
	return &MixCoord_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", _a0, _a1)}
}

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

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

func (_c *MixCoord_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_AlterCollectionFunction_Call {
	_c.Call.Return(run)
	return _c
}

// AlterDatabase provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) AlterDatabase(_a0 context.Context, _a1 *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AlterDatabaseRequest) *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, *rootcoordpb.AlterDatabaseRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterDatabase is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.AlterDatabaseRequest
func (_e *MixCoord_Expecter) AlterDatabase(_a0 interface{}, _a1 interface{}) *MixCoord_AlterDatabase_Call {
	return &MixCoord_AlterDatabase_Call{Call: _e.mock.On("AlterDatabase", _a0, _a1)}
}

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

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

func (_c *MixCoord_AlterDatabase_Call) RunAndReturn(run func(context.Context, *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error)) *MixCoord_AlterDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// AlterIndex provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// AssignSegmentID provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// BackupRBAC provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) BackupRBAC(_a0 context.Context, _a1 *milvuspb.BackupRBACMetaRequest) (*milvuspb.BackupRBACMetaResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// BackupRBAC is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.BackupRBACMetaRequest
func (_e *MixCoord_Expecter) BackupRBAC(_a0 interface{}, _a1 interface{}) *MixCoord_BackupRBAC_Call {
	return &MixCoord_BackupRBAC_Call{Call: _e.mock.On("BackupRBAC", _a0, _a1)}
}

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

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

func (_c *MixCoord_BackupRBAC_Call) RunAndReturn(run func(context.Context, *milvuspb.BackupRBACMetaRequest) (*milvuspb.BackupRBACMetaResponse, error)) *MixCoord_BackupRBAC_Call {
	_c.Call.Return(run)
	return _c
}

// BroadcastAlteredCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// CheckBalanceStatus provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CheckBalanceStatus(_a0 context.Context, _a1 *querypb.CheckBalanceStatusRequest) (*querypb.CheckBalanceStatusResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// CheckBalanceStatus is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.CheckBalanceStatusRequest
func (_e *MixCoord_Expecter) CheckBalanceStatus(_a0 interface{}, _a1 interface{}) *MixCoord_CheckBalanceStatus_Call {
	return &MixCoord_CheckBalanceStatus_Call{Call: _e.mock.On("CheckBalanceStatus", _a0, _a1)}
}

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

func (_c *MixCoord_CheckBalanceStatus_Call) Return(_a0 *querypb.CheckBalanceStatusResponse, _a1 error) *MixCoord_CheckBalanceStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_CheckBalanceStatus_Call) RunAndReturn(run func(context.Context, *querypb.CheckBalanceStatusRequest) (*querypb.CheckBalanceStatusResponse, error)) *MixCoord_CheckBalanceStatus_Call {
	_c.Call.Return(run)
	return _c
}

// CheckHealth provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// CheckQueryNodeDistribution provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CheckQueryNodeDistribution(_a0 context.Context, _a1 *querypb.CheckQueryNodeDistributionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckQueryNodeDistributionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckQueryNodeDistributionRequest) *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, *querypb.CheckQueryNodeDistributionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CheckQueryNodeDistribution is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.CheckQueryNodeDistributionRequest
func (_e *MixCoord_Expecter) CheckQueryNodeDistribution(_a0 interface{}, _a1 interface{}) *MixCoord_CheckQueryNodeDistribution_Call {
	return &MixCoord_CheckQueryNodeDistribution_Call{Call: _e.mock.On("CheckQueryNodeDistribution", _a0, _a1)}
}

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

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

func (_c *MixCoord_CheckQueryNodeDistribution_Call) RunAndReturn(run func(context.Context, *querypb.CheckQueryNodeDistributionRequest) (*commonpb.Status, error)) *MixCoord_CheckQueryNodeDistribution_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAlias provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateAlias(_a0 context.Context, _a1 *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateAliasRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateAliasRequest) *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, *milvuspb.CreateAliasRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateAlias is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateAliasRequest
func (_e *MixCoord_Expecter) CreateAlias(_a0 interface{}, _a1 interface{}) *MixCoord_CreateAlias_Call {
	return &MixCoord_CreateAlias_Call{Call: _e.mock.On("CreateAlias", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateAlias_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateAliasRequest) (*commonpb.Status, error)) *MixCoord_CreateAlias_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateCollection(_a0 context.Context, _a1 *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateCollectionRequest) *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, *milvuspb.CreateCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateCollectionRequest
func (_e *MixCoord_Expecter) CreateCollection(_a0 interface{}, _a1 interface{}) *MixCoord_CreateCollection_Call {
	return &MixCoord_CreateCollection_Call{Call: _e.mock.On("CreateCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateCollectionRequest) (*commonpb.Status, error)) *MixCoord_CreateCollection_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCredential provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateCredential(_a0 context.Context, _a1 *internalpb.CredentialInfo) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) *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, *internalpb.CredentialInfo) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateCredential is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.CredentialInfo
func (_e *MixCoord_Expecter) CreateCredential(_a0 interface{}, _a1 interface{}) *MixCoord_CreateCredential_Call {
	return &MixCoord_CreateCredential_Call{Call: _e.mock.On("CreateCredential", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateCredential_Call) RunAndReturn(run func(context.Context, *internalpb.CredentialInfo) (*commonpb.Status, error)) *MixCoord_CreateCredential_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDatabase provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateDatabase(_a0 context.Context, _a1 *milvuspb.CreateDatabaseRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateDatabaseRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateDatabaseRequest) *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, *milvuspb.CreateDatabaseRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateDatabase is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateDatabaseRequest
func (_e *MixCoord_Expecter) CreateDatabase(_a0 interface{}, _a1 interface{}) *MixCoord_CreateDatabase_Call {
	return &MixCoord_CreateDatabase_Call{Call: _e.mock.On("CreateDatabase", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateDatabase_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateDatabaseRequest) (*commonpb.Status, error)) *MixCoord_CreateDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// CreateExternalCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateExternalCollection(_a0 context.Context, _a1 *msgpb.CreateCollectionRequest) (*datapb.CreateExternalCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// CreateExternalCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *msgpb.CreateCollectionRequest
func (_e *MixCoord_Expecter) CreateExternalCollection(_a0 interface{}, _a1 interface{}) *MixCoord_CreateExternalCollection_Call {
	return &MixCoord_CreateExternalCollection_Call{Call: _e.mock.On("CreateExternalCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateExternalCollection_Call) RunAndReturn(run func(context.Context, *msgpb.CreateCollectionRequest) (*datapb.CreateExternalCollectionResponse, error)) *MixCoord_CreateExternalCollection_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIndex provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// CreatePartition provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreatePartition(_a0 context.Context, _a1 *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePartitionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePartitionRequest) *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, *milvuspb.CreatePartitionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreatePartition is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreatePartitionRequest
func (_e *MixCoord_Expecter) CreatePartition(_a0 interface{}, _a1 interface{}) *MixCoord_CreatePartition_Call {
	return &MixCoord_CreatePartition_Call{Call: _e.mock.On("CreatePartition", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreatePartition_Call) RunAndReturn(run func(context.Context, *milvuspb.CreatePartitionRequest) (*commonpb.Status, error)) *MixCoord_CreatePartition_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivilegeGroup provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreatePrivilegeGroup(_a0 context.Context, _a1 *milvuspb.CreatePrivilegeGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePrivilegeGroupRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePrivilegeGroupRequest) *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, *milvuspb.CreatePrivilegeGroupRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreatePrivilegeGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreatePrivilegeGroupRequest
func (_e *MixCoord_Expecter) CreatePrivilegeGroup(_a0 interface{}, _a1 interface{}) *MixCoord_CreatePrivilegeGroup_Call {
	return &MixCoord_CreatePrivilegeGroup_Call{Call: _e.mock.On("CreatePrivilegeGroup", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreatePrivilegeGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.CreatePrivilegeGroupRequest) (*commonpb.Status, error)) *MixCoord_CreatePrivilegeGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateResourceGroup provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateResourceGroup(_a0 context.Context, _a1 *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest) *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, *milvuspb.CreateResourceGroupRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateResourceGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateResourceGroupRequest
func (_e *MixCoord_Expecter) CreateResourceGroup(_a0 interface{}, _a1 interface{}) *MixCoord_CreateResourceGroup_Call {
	return &MixCoord_CreateResourceGroup_Call{Call: _e.mock.On("CreateResourceGroup", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateResourceGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error)) *MixCoord_CreateResourceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRole provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) CreateRole(_a0 context.Context, _a1 *milvuspb.CreateRoleRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateRoleRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateRoleRequest) *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, *milvuspb.CreateRoleRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateRoleRequest
func (_e *MixCoord_Expecter) CreateRole(_a0 interface{}, _a1 interface{}) *MixCoord_CreateRole_Call {
	return &MixCoord_CreateRole_Call{Call: _e.mock.On("CreateRole", _a0, _a1)}
}

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

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

func (_c *MixCoord_CreateRole_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateRoleRequest) (*commonpb.Status, error)) *MixCoord_CreateRole_Call {
	_c.Call.Return(run)
	return _c
}

// DeactivateChecker provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DeactivateChecker(_a0 context.Context, _a1 *querypb.DeactivateCheckerRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeactivateCheckerRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeactivateCheckerRequest) *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, *querypb.DeactivateCheckerRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeactivateChecker is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.DeactivateCheckerRequest
func (_e *MixCoord_Expecter) DeactivateChecker(_a0 interface{}, _a1 interface{}) *MixCoord_DeactivateChecker_Call {
	return &MixCoord_DeactivateChecker_Call{Call: _e.mock.On("DeactivateChecker", _a0, _a1)}
}

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

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

func (_c *MixCoord_DeactivateChecker_Call) RunAndReturn(run func(context.Context, *querypb.DeactivateCheckerRequest) (*commonpb.Status, error)) *MixCoord_DeactivateChecker_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCredential provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DeleteCredential(_a0 context.Context, _a1 *milvuspb.DeleteCredentialRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DeleteCredentialRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DeleteCredentialRequest) *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, *milvuspb.DeleteCredentialRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteCredential is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DeleteCredentialRequest
func (_e *MixCoord_Expecter) DeleteCredential(_a0 interface{}, _a1 interface{}) *MixCoord_DeleteCredential_Call {
	return &MixCoord_DeleteCredential_Call{Call: _e.mock.On("DeleteCredential", _a0, _a1)}
}

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

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

func (_c *MixCoord_DeleteCredential_Call) RunAndReturn(run func(context.Context, *milvuspb.DeleteCredentialRequest) (*commonpb.Status, error)) *MixCoord_DeleteCredential_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAlias provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DescribeAlias(_a0 context.Context, _a1 *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeAlias is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DescribeAliasRequest
func (_e *MixCoord_Expecter) DescribeAlias(_a0 interface{}, _a1 interface{}) *MixCoord_DescribeAlias_Call {
	return &MixCoord_DescribeAlias_Call{Call: _e.mock.On("DescribeAlias", _a0, _a1)}
}

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

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

func (_c *MixCoord_DescribeAlias_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error)) *MixCoord_DescribeAlias_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DescribeCollection(_a0 context.Context, _a1 *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DescribeCollectionRequest
func (_e *MixCoord_Expecter) DescribeCollection(_a0 interface{}, _a1 interface{}) *MixCoord_DescribeCollection_Call {
	return &MixCoord_DescribeCollection_Call{Call: _e.mock.On("DescribeCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_DescribeCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)) *MixCoord_DescribeCollection_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCollectionInternal provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DescribeCollectionInternal(_a0 context.Context, _a1 *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeCollectionInternal is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DescribeCollectionRequest
func (_e *MixCoord_Expecter) DescribeCollectionInternal(_a0 interface{}, _a1 interface{}) *MixCoord_DescribeCollectionInternal_Call {
	return &MixCoord_DescribeCollectionInternal_Call{Call: _e.mock.On("DescribeCollectionInternal", _a0, _a1)}
}

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

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

func (_c *MixCoord_DescribeCollectionInternal_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)) *MixCoord_DescribeCollectionInternal_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeDatabase provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DescribeDatabase(_a0 context.Context, _a1 *rootcoordpb.DescribeDatabaseRequest) (*rootcoordpb.DescribeDatabaseResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeDatabase is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.DescribeDatabaseRequest
func (_e *MixCoord_Expecter) DescribeDatabase(_a0 interface{}, _a1 interface{}) *MixCoord_DescribeDatabase_Call {
	return &MixCoord_DescribeDatabase_Call{Call: _e.mock.On("DescribeDatabase", _a0, _a1)}
}

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

func (_c *MixCoord_DescribeDatabase_Call) Return(_a0 *rootcoordpb.DescribeDatabaseResponse, _a1 error) *MixCoord_DescribeDatabase_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_DescribeDatabase_Call) RunAndReturn(run func(context.Context, *rootcoordpb.DescribeDatabaseRequest) (*rootcoordpb.DescribeDatabaseResponse, error)) *MixCoord_DescribeDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIndex provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// DescribeResourceGroup provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DescribeResourceGroup(_a0 context.Context, _a1 *querypb.DescribeResourceGroupRequest) (*querypb.DescribeResourceGroupResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeResourceGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.DescribeResourceGroupRequest
func (_e *MixCoord_Expecter) DescribeResourceGroup(_a0 interface{}, _a1 interface{}) *MixCoord_DescribeResourceGroup_Call {
	return &MixCoord_DescribeResourceGroup_Call{Call: _e.mock.On("DescribeResourceGroup", _a0, _a1)}
}

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

func (_c *MixCoord_DescribeResourceGroup_Call) Return(_a0 *querypb.DescribeResourceGroupResponse, _a1 error) *MixCoord_DescribeResourceGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_DescribeResourceGroup_Call) RunAndReturn(run func(context.Context, *querypb.DescribeResourceGroupRequest) (*querypb.DescribeResourceGroupResponse, error)) *MixCoord_DescribeResourceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DropAlias provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropAlias(_a0 context.Context, _a1 *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropAliasRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropAliasRequest) *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, *milvuspb.DropAliasRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropAlias is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropAliasRequest
func (_e *MixCoord_Expecter) DropAlias(_a0 interface{}, _a1 interface{}) *MixCoord_DropAlias_Call {
	return &MixCoord_DropAlias_Call{Call: _e.mock.On("DropAlias", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropAlias_Call) RunAndReturn(run func(context.Context, *milvuspb.DropAliasRequest) (*commonpb.Status, error)) *MixCoord_DropAlias_Call {
	_c.Call.Return(run)
	return _c
}

// DropCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropCollection(_a0 context.Context, _a1 *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionRequest) *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, *milvuspb.DropCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropCollectionRequest
func (_e *MixCoord_Expecter) DropCollection(_a0 interface{}, _a1 interface{}) *MixCoord_DropCollection_Call {
	return &MixCoord_DropCollection_Call{Call: _e.mock.On("DropCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionRequest) (*commonpb.Status, error)) *MixCoord_DropCollection_Call {
	_c.Call.Return(run)
	return _c
}

// DropCollectionFunction provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropCollectionFunction(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) *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, *milvuspb.DropCollectionFunctionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropCollectionFunction is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropCollectionFunctionRequest
func (_e *MixCoord_Expecter) DropCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_DropCollectionFunction_Call {
	return &MixCoord_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_DropCollectionFunction_Call {
	_c.Call.Return(run)
	return _c
}

// DropDatabase provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropDatabase(_a0 context.Context, _a1 *milvuspb.DropDatabaseRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropDatabaseRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropDatabaseRequest) *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, *milvuspb.DropDatabaseRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropDatabase is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropDatabaseRequest
func (_e *MixCoord_Expecter) DropDatabase(_a0 interface{}, _a1 interface{}) *MixCoord_DropDatabase_Call {
	return &MixCoord_DropDatabase_Call{Call: _e.mock.On("DropDatabase", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropDatabase_Call) RunAndReturn(run func(context.Context, *milvuspb.DropDatabaseRequest) (*commonpb.Status, error)) *MixCoord_DropDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// DropIndex provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// DropPartition provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropPartition(_a0 context.Context, _a1 *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPartitionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPartitionRequest) *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, *milvuspb.DropPartitionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropPartition is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropPartitionRequest
func (_e *MixCoord_Expecter) DropPartition(_a0 interface{}, _a1 interface{}) *MixCoord_DropPartition_Call {
	return &MixCoord_DropPartition_Call{Call: _e.mock.On("DropPartition", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropPartition_Call) RunAndReturn(run func(context.Context, *milvuspb.DropPartitionRequest) (*commonpb.Status, error)) *MixCoord_DropPartition_Call {
	_c.Call.Return(run)
	return _c
}

// DropPrivilegeGroup provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropPrivilegeGroup(_a0 context.Context, _a1 *milvuspb.DropPrivilegeGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPrivilegeGroupRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPrivilegeGroupRequest) *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, *milvuspb.DropPrivilegeGroupRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropPrivilegeGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropPrivilegeGroupRequest
func (_e *MixCoord_Expecter) DropPrivilegeGroup(_a0 interface{}, _a1 interface{}) *MixCoord_DropPrivilegeGroup_Call {
	return &MixCoord_DropPrivilegeGroup_Call{Call: _e.mock.On("DropPrivilegeGroup", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropPrivilegeGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.DropPrivilegeGroupRequest) (*commonpb.Status, error)) *MixCoord_DropPrivilegeGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DropResourceGroup provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropResourceGroup(_a0 context.Context, _a1 *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest) *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, *milvuspb.DropResourceGroupRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropResourceGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropResourceGroupRequest
func (_e *MixCoord_Expecter) DropResourceGroup(_a0 interface{}, _a1 interface{}) *MixCoord_DropResourceGroup_Call {
	return &MixCoord_DropResourceGroup_Call{Call: _e.mock.On("DropResourceGroup", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropResourceGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error)) *MixCoord_DropResourceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DropRole provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) DropRole(_a0 context.Context, _a1 *milvuspb.DropRoleRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropRoleRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropRoleRequest) *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, *milvuspb.DropRoleRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropRoleRequest
func (_e *MixCoord_Expecter) DropRole(_a0 interface{}, _a1 interface{}) *MixCoord_DropRole_Call {
	return &MixCoord_DropRole_Call{Call: _e.mock.On("DropRole", _a0, _a1)}
}

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

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

func (_c *MixCoord_DropRole_Call) RunAndReturn(run func(context.Context, *milvuspb.DropRoleRequest) (*commonpb.Status, error)) *MixCoord_DropRole_Call {
	_c.Call.Return(run)
	return _c
}

// DropVirtualChannel provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// Flush provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// FlushAll provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GcConfirm provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GcControl provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetChannelRecoveryInfo provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetCollectionStatistics provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetCompactionState provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetCompactionStateWithPlans provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetComponentStates provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetComponentStates(_a0 context.Context, _a1 *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetComponentStates is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetComponentStatesRequest
func (_e *MixCoord_Expecter) GetComponentStates(_a0 interface{}, _a1 interface{}) *MixCoord_GetComponentStates_Call {
	return &MixCoord_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", _a0, _a1)}
}

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

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

func (_c *MixCoord_GetComponentStates_Call) RunAndReturn(run func(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)) *MixCoord_GetComponentStates_Call {
	_c.Call.Return(run)
	return _c
}

// GetCredential provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetCredential(_a0 context.Context, _a1 *rootcoordpb.GetCredentialRequest) (*rootcoordpb.GetCredentialResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetCredential is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.GetCredentialRequest
func (_e *MixCoord_Expecter) GetCredential(_a0 interface{}, _a1 interface{}) *MixCoord_GetCredential_Call {
	return &MixCoord_GetCredential_Call{Call: _e.mock.On("GetCredential", _a0, _a1)}
}

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

func (_c *MixCoord_GetCredential_Call) Return(_a0 *rootcoordpb.GetCredentialResponse, _a1 error) *MixCoord_GetCredential_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_GetCredential_Call) RunAndReturn(run func(context.Context, *rootcoordpb.GetCredentialRequest) (*rootcoordpb.GetCredentialResponse, error)) *MixCoord_GetCredential_Call {
	_c.Call.Return(run)
	return _c
}

// GetDcMetrics provides a mock function with given fields: ctx, req
func (_m *MixCoord) GetDcMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
	ret := _m.Called(ctx, req)

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

	var r0 *milvuspb.GetMetricsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDcMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - req *milvuspb.GetMetricsRequest
func (_e *MixCoord_Expecter) GetDcMetrics(ctx interface{}, req interface{}) *MixCoord_GetDcMetrics_Call {
	return &MixCoord_GetDcMetrics_Call{Call: _e.mock.On("GetDcMetrics", ctx, req)}
}

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

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

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

// GetFlushAllState provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetFlushState provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetFlushedSegments provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetImportProgress provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetIndexBuildProgress provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetIndexInfos provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetIndexState provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetIndexStatistics provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetInsertBinlogPaths provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// GetLoadSegmentInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.GetSegmentInfoRequest
func (_e *MixCoord_Expecter) GetLoadSegmentInfo(_a0 interface{}, _a1 interface{}) *MixCoord_GetLoadSegmentInfo_Call {
	return &MixCoord_GetLoadSegmentInfo_Call{Call: _e.mock.On("GetLoadSegmentInfo", _a0, _a1)}
}

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

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

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

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

	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(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - req *milvuspb.GetMetricsRequest
func (_e *MixCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *MixCoord_GetMetrics_Call {
	return &MixCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)}
}

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

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

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

// GetPChannelInfo provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetPChannelInfo(_a0 context.Context, _a1 *rootcoordpb.GetPChannelInfoRequest) (*rootcoordpb.GetPChannelInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetPChannelInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.GetPChannelInfoRequest
func (_e *MixCoord_Expecter) GetPChannelInfo(_a0 interface{}, _a1 interface{}) *MixCoord_GetPChannelInfo_Call {
	return &MixCoord_GetPChannelInfo_Call{Call: _e.mock.On("GetPChannelInfo", _a0, _a1)}
}

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

func (_c *MixCoord_GetPChannelInfo_Call) Return(_a0 *rootcoordpb.GetPChannelInfoResponse, _a1 error) *MixCoord_GetPChannelInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_GetPChannelInfo_Call) RunAndReturn(run func(context.Context, *rootcoordpb.GetPChannelInfoRequest) (*rootcoordpb.GetPChannelInfoResponse, error)) *MixCoord_GetPChannelInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetPartitionStates provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetPartitionStates(_a0 context.Context, _a1 *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetPartitionStates is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.GetPartitionStatesRequest
func (_e *MixCoord_Expecter) GetPartitionStates(_a0 interface{}, _a1 interface{}) *MixCoord_GetPartitionStates_Call {
	return &MixCoord_GetPartitionStates_Call{Call: _e.mock.On("GetPartitionStates", _a0, _a1)}
}

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

func (_c *MixCoord_GetPartitionStates_Call) Return(_a0 *querypb.GetPartitionStatesResponse, _a1 error) *MixCoord_GetPartitionStates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_GetPartitionStates_Call) RunAndReturn(run func(context.Context, *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error)) *MixCoord_GetPartitionStates_Call {
	_c.Call.Return(run)
	return _c
}

// GetPartitionStatistics provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetQcMetrics provides a mock function with given fields: ctx, req
func (_m *MixCoord) GetQcMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
	ret := _m.Called(ctx, req)

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

	var r0 *milvuspb.GetMetricsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetQcMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - req *milvuspb.GetMetricsRequest
func (_e *MixCoord_Expecter) GetQcMetrics(ctx interface{}, req interface{}) *MixCoord_GetQcMetrics_Call {
	return &MixCoord_GetQcMetrics_Call{Call: _e.mock.On("GetQcMetrics", ctx, req)}
}

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

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

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

// GetQueryNodeDistribution provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetQueryNodeDistribution(_a0 context.Context, _a1 *querypb.GetQueryNodeDistributionRequest) (*querypb.GetQueryNodeDistributionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetQueryNodeDistribution is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.GetQueryNodeDistributionRequest
func (_e *MixCoord_Expecter) GetQueryNodeDistribution(_a0 interface{}, _a1 interface{}) *MixCoord_GetQueryNodeDistribution_Call {
	return &MixCoord_GetQueryNodeDistribution_Call{Call: _e.mock.On("GetQueryNodeDistribution", _a0, _a1)}
}

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

func (_c *MixCoord_GetQueryNodeDistribution_Call) Return(_a0 *querypb.GetQueryNodeDistributionResponse, _a1 error) *MixCoord_GetQueryNodeDistribution_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_GetQueryNodeDistribution_Call) RunAndReturn(run func(context.Context, *querypb.GetQueryNodeDistributionRequest) (*querypb.GetQueryNodeDistributionResponse, error)) *MixCoord_GetQueryNodeDistribution_Call {
	_c.Call.Return(run)
	return _c
}

// GetQuotaMetrics provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetQuotaMetrics(_a0 context.Context, _a1 *internalpb.GetQuotaMetricsRequest) (*internalpb.GetQuotaMetricsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetQuotaMetrics is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.GetQuotaMetricsRequest
func (_e *MixCoord_Expecter) GetQuotaMetrics(_a0 interface{}, _a1 interface{}) *MixCoord_GetQuotaMetrics_Call {
	return &MixCoord_GetQuotaMetrics_Call{Call: _e.mock.On("GetQuotaMetrics", _a0, _a1)}
}

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

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

func (_c *MixCoord_GetQuotaMetrics_Call) RunAndReturn(run func(context.Context, *internalpb.GetQuotaMetricsRequest) (*internalpb.GetQuotaMetricsResponse, error)) *MixCoord_GetQuotaMetrics_Call {
	_c.Call.Return(run)
	return _c
}

// GetRecoveryInfo provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetRecoveryInfoV2 provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetReplicas provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetReplicas(_a0 context.Context, _a1 *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetReplicas is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetReplicasRequest
func (_e *MixCoord_Expecter) GetReplicas(_a0 interface{}, _a1 interface{}) *MixCoord_GetReplicas_Call {
	return &MixCoord_GetReplicas_Call{Call: _e.mock.On("GetReplicas", _a0, _a1)}
}

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

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

func (_c *MixCoord_GetReplicas_Call) RunAndReturn(run func(context.Context, *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error)) *MixCoord_GetReplicas_Call {
	_c.Call.Return(run)
	return _c
}

// GetSegmentIndexState provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetSegmentInfo provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetSegmentInfoChannel provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetSegmentStates provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetSegmentsByStates provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// GetShardLeaders provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetShardLeaders(_a0 context.Context, _a1 *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetShardLeaders is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.GetShardLeadersRequest
func (_e *MixCoord_Expecter) GetShardLeaders(_a0 interface{}, _a1 interface{}) *MixCoord_GetShardLeaders_Call {
	return &MixCoord_GetShardLeaders_Call{Call: _e.mock.On("GetShardLeaders", _a0, _a1)}
}

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

func (_c *MixCoord_GetShardLeaders_Call) Return(_a0 *querypb.GetShardLeadersResponse, _a1 error) *MixCoord_GetShardLeaders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_GetShardLeaders_Call) RunAndReturn(run func(context.Context, *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error)) *MixCoord_GetShardLeaders_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatisticsChannel provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetStatisticsChannel(_a0 context.Context, _a1 *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *milvuspb.StringResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetStatisticsChannelRequest) *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, *internalpb.GetStatisticsChannelRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetStatisticsChannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.GetStatisticsChannelRequest
func (_e *MixCoord_Expecter) GetStatisticsChannel(_a0 interface{}, _a1 interface{}) *MixCoord_GetStatisticsChannel_Call {
	return &MixCoord_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", _a0, _a1)}
}

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

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

func (_c *MixCoord_GetStatisticsChannel_Call) RunAndReturn(run func(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)) *MixCoord_GetStatisticsChannel_Call {
	_c.Call.Return(run)
	return _c
}

// GetTimeTickChannel provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) GetTimeTickChannel(_a0 context.Context, _a1 *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *milvuspb.StringResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetTimeTickChannelRequest) *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, *internalpb.GetTimeTickChannelRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetTimeTickChannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.GetTimeTickChannelRequest
func (_e *MixCoord_Expecter) GetTimeTickChannel(_a0 interface{}, _a1 interface{}) *MixCoord_GetTimeTickChannel_Call {
	return &MixCoord_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", _a0, _a1)}
}

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

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

func (_c *MixCoord_GetTimeTickChannel_Call) RunAndReturn(run func(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)) *MixCoord_GetTimeTickChannel_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// GracefulStop is a helper method to define mock.On call
func (_e *MixCoord_Expecter) GracefulStop() *MixCoord_GracefulStop_Call {
	return &MixCoord_GracefulStop_Call{Call: _e.mock.On("GracefulStop")}
}

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

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

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

// HasCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) HasCollection(_a0 context.Context, _a1 *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// HasCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.HasCollectionRequest
func (_e *MixCoord_Expecter) HasCollection(_a0 interface{}, _a1 interface{}) *MixCoord_HasCollection_Call {
	return &MixCoord_HasCollection_Call{Call: _e.mock.On("HasCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_HasCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error)) *MixCoord_HasCollection_Call {
	_c.Call.Return(run)
	return _c
}

// HasPartition provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) HasPartition(_a0 context.Context, _a1 *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// HasPartition is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.HasPartitionRequest
func (_e *MixCoord_Expecter) HasPartition(_a0 interface{}, _a1 interface{}) *MixCoord_HasPartition_Call {
	return &MixCoord_HasPartition_Call{Call: _e.mock.On("HasPartition", _a0, _a1)}
}

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

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

func (_c *MixCoord_HasPartition_Call) RunAndReturn(run func(context.Context, *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error)) *MixCoord_HasPartition_Call {
	_c.Call.Return(run)
	return _c
}

// ImportV2 provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// Init provides a mock function with no fields
func (_m *MixCoord) 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
}

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

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

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

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

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

// InvalidateCollectionMetaCache provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) InvalidateCollectionMetaCache(_a0 context.Context, _a1 *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest) *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, *proxypb.InvalidateCollMetaCacheRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InvalidateCollectionMetaCache is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *proxypb.InvalidateCollMetaCacheRequest
func (_e *MixCoord_Expecter) InvalidateCollectionMetaCache(_a0 interface{}, _a1 interface{}) *MixCoord_InvalidateCollectionMetaCache_Call {
	return &MixCoord_InvalidateCollectionMetaCache_Call{Call: _e.mock.On("InvalidateCollectionMetaCache", _a0, _a1)}
}

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

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

func (_c *MixCoord_InvalidateCollectionMetaCache_Call) RunAndReturn(run func(context.Context, *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error)) *MixCoord_InvalidateCollectionMetaCache_Call {
	_c.Call.Return(run)
	return _c
}

// ListAliases provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListAliases(_a0 context.Context, _a1 *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListAliases is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListAliasesRequest
func (_e *MixCoord_Expecter) ListAliases(_a0 interface{}, _a1 interface{}) *MixCoord_ListAliases_Call {
	return &MixCoord_ListAliases_Call{Call: _e.mock.On("ListAliases", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListAliases_Call) RunAndReturn(run func(context.Context, *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error)) *MixCoord_ListAliases_Call {
	_c.Call.Return(run)
	return _c
}

// ListCheckers provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListCheckers(_a0 context.Context, _a1 *querypb.ListCheckersRequest) (*querypb.ListCheckersResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListCheckers is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ListCheckersRequest
func (_e *MixCoord_Expecter) ListCheckers(_a0 interface{}, _a1 interface{}) *MixCoord_ListCheckers_Call {
	return &MixCoord_ListCheckers_Call{Call: _e.mock.On("ListCheckers", _a0, _a1)}
}

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

func (_c *MixCoord_ListCheckers_Call) Return(_a0 *querypb.ListCheckersResponse, _a1 error) *MixCoord_ListCheckers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_ListCheckers_Call) RunAndReturn(run func(context.Context, *querypb.ListCheckersRequest) (*querypb.ListCheckersResponse, error)) *MixCoord_ListCheckers_Call {
	_c.Call.Return(run)
	return _c
}

// ListCredUsers provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListCredUsers(_a0 context.Context, _a1 *milvuspb.ListCredUsersRequest) (*milvuspb.ListCredUsersResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListCredUsers is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListCredUsersRequest
func (_e *MixCoord_Expecter) ListCredUsers(_a0 interface{}, _a1 interface{}) *MixCoord_ListCredUsers_Call {
	return &MixCoord_ListCredUsers_Call{Call: _e.mock.On("ListCredUsers", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListCredUsers_Call) RunAndReturn(run func(context.Context, *milvuspb.ListCredUsersRequest) (*milvuspb.ListCredUsersResponse, error)) *MixCoord_ListCredUsers_Call {
	_c.Call.Return(run)
	return _c
}

// ListDatabases provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListDatabases(_a0 context.Context, _a1 *milvuspb.ListDatabasesRequest) (*milvuspb.ListDatabasesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListDatabases is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListDatabasesRequest
func (_e *MixCoord_Expecter) ListDatabases(_a0 interface{}, _a1 interface{}) *MixCoord_ListDatabases_Call {
	return &MixCoord_ListDatabases_Call{Call: _e.mock.On("ListDatabases", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListDatabases_Call) RunAndReturn(run func(context.Context, *milvuspb.ListDatabasesRequest) (*milvuspb.ListDatabasesResponse, error)) *MixCoord_ListDatabases_Call {
	_c.Call.Return(run)
	return _c
}

// ListFileResources provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListFileResources(_a0 context.Context, _a1 *milvuspb.ListFileResourcesRequest) (*milvuspb.ListFileResourcesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListFileResources is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListFileResourcesRequest
func (_e *MixCoord_Expecter) ListFileResources(_a0 interface{}, _a1 interface{}) *MixCoord_ListFileResources_Call {
	return &MixCoord_ListFileResources_Call{Call: _e.mock.On("ListFileResources", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListFileResources_Call) RunAndReturn(run func(context.Context, *milvuspb.ListFileResourcesRequest) (*milvuspb.ListFileResourcesResponse, error)) *MixCoord_ListFileResources_Call {
	_c.Call.Return(run)
	return _c
}

// ListImports provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// ListIndexes provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// ListLoadedSegments provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListLoadedSegments(_a0 context.Context, _a1 *querypb.ListLoadedSegmentsRequest) (*querypb.ListLoadedSegmentsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListLoadedSegments is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ListLoadedSegmentsRequest
func (_e *MixCoord_Expecter) ListLoadedSegments(_a0 interface{}, _a1 interface{}) *MixCoord_ListLoadedSegments_Call {
	return &MixCoord_ListLoadedSegments_Call{Call: _e.mock.On("ListLoadedSegments", _a0, _a1)}
}

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

func (_c *MixCoord_ListLoadedSegments_Call) Return(_a0 *querypb.ListLoadedSegmentsResponse, _a1 error) *MixCoord_ListLoadedSegments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_ListLoadedSegments_Call) RunAndReturn(run func(context.Context, *querypb.ListLoadedSegmentsRequest) (*querypb.ListLoadedSegmentsResponse, error)) *MixCoord_ListLoadedSegments_Call {
	_c.Call.Return(run)
	return _c
}

// ListPolicy provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListPolicy(_a0 context.Context, _a1 *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListPolicy is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.ListPolicyRequest
func (_e *MixCoord_Expecter) ListPolicy(_a0 interface{}, _a1 interface{}) *MixCoord_ListPolicy_Call {
	return &MixCoord_ListPolicy_Call{Call: _e.mock.On("ListPolicy", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListPolicy_Call) RunAndReturn(run func(context.Context, *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error)) *MixCoord_ListPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ListPrivilegeGroups provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListPrivilegeGroups(_a0 context.Context, _a1 *milvuspb.ListPrivilegeGroupsRequest) (*milvuspb.ListPrivilegeGroupsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListPrivilegeGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListPrivilegeGroupsRequest
func (_e *MixCoord_Expecter) ListPrivilegeGroups(_a0 interface{}, _a1 interface{}) *MixCoord_ListPrivilegeGroups_Call {
	return &MixCoord_ListPrivilegeGroups_Call{Call: _e.mock.On("ListPrivilegeGroups", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListPrivilegeGroups_Call) RunAndReturn(run func(context.Context, *milvuspb.ListPrivilegeGroupsRequest) (*milvuspb.ListPrivilegeGroupsResponse, error)) *MixCoord_ListPrivilegeGroups_Call {
	_c.Call.Return(run)
	return _c
}

// ListQueryNode provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListQueryNode(_a0 context.Context, _a1 *querypb.ListQueryNodeRequest) (*querypb.ListQueryNodeResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListQueryNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ListQueryNodeRequest
func (_e *MixCoord_Expecter) ListQueryNode(_a0 interface{}, _a1 interface{}) *MixCoord_ListQueryNode_Call {
	return &MixCoord_ListQueryNode_Call{Call: _e.mock.On("ListQueryNode", _a0, _a1)}
}

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

func (_c *MixCoord_ListQueryNode_Call) Return(_a0 *querypb.ListQueryNodeResponse, _a1 error) *MixCoord_ListQueryNode_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_ListQueryNode_Call) RunAndReturn(run func(context.Context, *querypb.ListQueryNodeRequest) (*querypb.ListQueryNodeResponse, error)) *MixCoord_ListQueryNode_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceGroups provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ListResourceGroups(_a0 context.Context, _a1 *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListResourceGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListResourceGroupsRequest
func (_e *MixCoord_Expecter) ListResourceGroups(_a0 interface{}, _a1 interface{}) *MixCoord_ListResourceGroups_Call {
	return &MixCoord_ListResourceGroups_Call{Call: _e.mock.On("ListResourceGroups", _a0, _a1)}
}

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

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

func (_c *MixCoord_ListResourceGroups_Call) RunAndReturn(run func(context.Context, *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error)) *MixCoord_ListResourceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// LoadBalance provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) LoadBalance(_a0 context.Context, _a1 *querypb.LoadBalanceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest) *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, *querypb.LoadBalanceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoadBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.LoadBalanceRequest
func (_e *MixCoord_Expecter) LoadBalance(_a0 interface{}, _a1 interface{}) *MixCoord_LoadBalance_Call {
	return &MixCoord_LoadBalance_Call{Call: _e.mock.On("LoadBalance", _a0, _a1)}
}

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

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

func (_c *MixCoord_LoadBalance_Call) RunAndReturn(run func(context.Context, *querypb.LoadBalanceRequest) (*commonpb.Status, error)) *MixCoord_LoadBalance_Call {
	_c.Call.Return(run)
	return _c
}

// LoadCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) LoadCollection(_a0 context.Context, _a1 *querypb.LoadCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest) *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, *querypb.LoadCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoadCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.LoadCollectionRequest
func (_e *MixCoord_Expecter) LoadCollection(_a0 interface{}, _a1 interface{}) *MixCoord_LoadCollection_Call {
	return &MixCoord_LoadCollection_Call{Call: _e.mock.On("LoadCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_LoadCollection_Call) RunAndReturn(run func(context.Context, *querypb.LoadCollectionRequest) (*commonpb.Status, error)) *MixCoord_LoadCollection_Call {
	_c.Call.Return(run)
	return _c
}

// LoadPartitions provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) LoadPartitions(_a0 context.Context, _a1 *querypb.LoadPartitionsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) *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, *querypb.LoadPartitionsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoadPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.LoadPartitionsRequest
func (_e *MixCoord_Expecter) LoadPartitions(_a0 interface{}, _a1 interface{}) *MixCoord_LoadPartitions_Call {
	return &MixCoord_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions", _a0, _a1)}
}

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

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

func (_c *MixCoord_LoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)) *MixCoord_LoadPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ManualCompaction provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// MarkSegmentsDropped provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// NotifyDropPartition provides a mock function with given fields: ctx, channel, partitionIDs
func (_m *MixCoord) NotifyDropPartition(ctx context.Context, channel string, partitionIDs []int64) error {
	ret := _m.Called(ctx, channel, partitionIDs)

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

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

	return r0
}

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

// NotifyDropPartition is a helper method to define mock.On call
//   - ctx context.Context
//   - channel string
//   - partitionIDs []int64
func (_e *MixCoord_Expecter) NotifyDropPartition(ctx interface{}, channel interface{}, partitionIDs interface{}) *MixCoord_NotifyDropPartition_Call {
	return &MixCoord_NotifyDropPartition_Call{Call: _e.mock.On("NotifyDropPartition", ctx, channel, partitionIDs)}
}

func (_c *MixCoord_NotifyDropPartition_Call) Run(run func(ctx context.Context, channel string, partitionIDs []int64)) *MixCoord_NotifyDropPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]int64))
	})
	return _c
}

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

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

// OperatePrivilege provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) OperatePrivilege(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest) *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, *milvuspb.OperatePrivilegeRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OperatePrivilege is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperatePrivilegeRequest
func (_e *MixCoord_Expecter) OperatePrivilege(_a0 interface{}, _a1 interface{}) *MixCoord_OperatePrivilege_Call {
	return &MixCoord_OperatePrivilege_Call{Call: _e.mock.On("OperatePrivilege", _a0, _a1)}
}

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

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

func (_c *MixCoord_OperatePrivilege_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)) *MixCoord_OperatePrivilege_Call {
	_c.Call.Return(run)
	return _c
}

// OperatePrivilegeGroup provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) OperatePrivilegeGroup(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) *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, *milvuspb.OperatePrivilegeGroupRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OperatePrivilegeGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperatePrivilegeGroupRequest
func (_e *MixCoord_Expecter) OperatePrivilegeGroup(_a0 interface{}, _a1 interface{}) *MixCoord_OperatePrivilegeGroup_Call {
	return &MixCoord_OperatePrivilegeGroup_Call{Call: _e.mock.On("OperatePrivilegeGroup", _a0, _a1)}
}

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

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

func (_c *MixCoord_OperatePrivilegeGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) (*commonpb.Status, error)) *MixCoord_OperatePrivilegeGroup_Call {
	_c.Call.Return(run)
	return _c
}

// OperateUserRole provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) OperateUserRole(_a0 context.Context, _a1 *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest) *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, *milvuspb.OperateUserRoleRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OperateUserRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperateUserRoleRequest
func (_e *MixCoord_Expecter) OperateUserRole(_a0 interface{}, _a1 interface{}) *MixCoord_OperateUserRole_Call {
	return &MixCoord_OperateUserRole_Call{Call: _e.mock.On("OperateUserRole", _a0, _a1)}
}

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

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

func (_c *MixCoord_OperateUserRole_Call) RunAndReturn(run func(context.Context, *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error)) *MixCoord_OperateUserRole_Call {
	_c.Call.Return(run)
	return _c
}

// Register provides a mock function with no fields
func (_m *MixCoord) 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
}

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

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

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

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

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

// RegisterStreamingCoordGRPCService provides a mock function with given fields: server
func (_m *MixCoord) RegisterStreamingCoordGRPCService(server *grpc.Server) {
	_m.Called(server)
}

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

// RegisterStreamingCoordGRPCService is a helper method to define mock.On call
//   - server *grpc.Server
func (_e *MixCoord_Expecter) RegisterStreamingCoordGRPCService(server interface{}) *MixCoord_RegisterStreamingCoordGRPCService_Call {
	return &MixCoord_RegisterStreamingCoordGRPCService_Call{Call: _e.mock.On("RegisterStreamingCoordGRPCService", server)}
}

func (_c *MixCoord_RegisterStreamingCoordGRPCService_Call) Run(run func(server *grpc.Server)) *MixCoord_RegisterStreamingCoordGRPCService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*grpc.Server))
	})
	return _c
}

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

func (_c *MixCoord_RegisterStreamingCoordGRPCService_Call) RunAndReturn(run func(*grpc.Server)) *MixCoord_RegisterStreamingCoordGRPCService_Call {
	_c.Run(run)
	return _c
}

// ReleaseCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ReleaseCollection(_a0 context.Context, _a1 *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) *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, *querypb.ReleaseCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ReleaseCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ReleaseCollectionRequest
func (_e *MixCoord_Expecter) ReleaseCollection(_a0 interface{}, _a1 interface{}) *MixCoord_ReleaseCollection_Call {
	return &MixCoord_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_ReleaseCollection_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)) *MixCoord_ReleaseCollection_Call {
	_c.Call.Return(run)
	return _c
}

// ReleasePartitions provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ReleasePartitions(_a0 context.Context, _a1 *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) *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, *querypb.ReleasePartitionsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ReleasePartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ReleasePartitionsRequest
func (_e *MixCoord_Expecter) ReleasePartitions(_a0 interface{}, _a1 interface{}) *MixCoord_ReleasePartitions_Call {
	return &MixCoord_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions", _a0, _a1)}
}

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

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

func (_c *MixCoord_ReleasePartitions_Call) RunAndReturn(run func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)) *MixCoord_ReleasePartitions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveFileResource provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) RemoveFileResource(_a0 context.Context, _a1 *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest) *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, *milvuspb.RemoveFileResourceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RemoveFileResource is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RemoveFileResourceRequest
func (_e *MixCoord_Expecter) RemoveFileResource(_a0 interface{}, _a1 interface{}) *MixCoord_RemoveFileResource_Call {
	return &MixCoord_RemoveFileResource_Call{Call: _e.mock.On("RemoveFileResource", _a0, _a1)}
}

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

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

func (_c *MixCoord_RemoveFileResource_Call) RunAndReturn(run func(context.Context, *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error)) *MixCoord_RemoveFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// RenameCollection provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) RenameCollection(_a0 context.Context, _a1 *milvuspb.RenameCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest) *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, *milvuspb.RenameCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RenameCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RenameCollectionRequest
func (_e *MixCoord_Expecter) RenameCollection(_a0 interface{}, _a1 interface{}) *MixCoord_RenameCollection_Call {
	return &MixCoord_RenameCollection_Call{Call: _e.mock.On("RenameCollection", _a0, _a1)}
}

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

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

func (_c *MixCoord_RenameCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.RenameCollectionRequest) (*commonpb.Status, error)) *MixCoord_RenameCollection_Call {
	_c.Call.Return(run)
	return _c
}

// ReportDataNodeTtMsgs provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// RestoreRBAC provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) RestoreRBAC(_a0 context.Context, _a1 *milvuspb.RestoreRBACMetaRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreRBACMetaRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreRBACMetaRequest) *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, *milvuspb.RestoreRBACMetaRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RestoreRBAC is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RestoreRBACMetaRequest
func (_e *MixCoord_Expecter) RestoreRBAC(_a0 interface{}, _a1 interface{}) *MixCoord_RestoreRBAC_Call {
	return &MixCoord_RestoreRBAC_Call{Call: _e.mock.On("RestoreRBAC", _a0, _a1)}
}

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

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

func (_c *MixCoord_RestoreRBAC_Call) RunAndReturn(run func(context.Context, *milvuspb.RestoreRBACMetaRequest) (*commonpb.Status, error)) *MixCoord_RestoreRBAC_Call {
	_c.Call.Return(run)
	return _c
}

// ResumeBalance provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ResumeBalance(_a0 context.Context, _a1 *querypb.ResumeBalanceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeBalanceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeBalanceRequest) *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, *querypb.ResumeBalanceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ResumeBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ResumeBalanceRequest
func (_e *MixCoord_Expecter) ResumeBalance(_a0 interface{}, _a1 interface{}) *MixCoord_ResumeBalance_Call {
	return &MixCoord_ResumeBalance_Call{Call: _e.mock.On("ResumeBalance", _a0, _a1)}
}

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

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

func (_c *MixCoord_ResumeBalance_Call) RunAndReturn(run func(context.Context, *querypb.ResumeBalanceRequest) (*commonpb.Status, error)) *MixCoord_ResumeBalance_Call {
	_c.Call.Return(run)
	return _c
}

// ResumeNode provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ResumeNode(_a0 context.Context, _a1 *querypb.ResumeNodeRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeNodeRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeNodeRequest) *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, *querypb.ResumeNodeRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ResumeNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ResumeNodeRequest
func (_e *MixCoord_Expecter) ResumeNode(_a0 interface{}, _a1 interface{}) *MixCoord_ResumeNode_Call {
	return &MixCoord_ResumeNode_Call{Call: _e.mock.On("ResumeNode", _a0, _a1)}
}

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

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

func (_c *MixCoord_ResumeNode_Call) RunAndReturn(run func(context.Context, *querypb.ResumeNodeRequest) (*commonpb.Status, error)) *MixCoord_ResumeNode_Call {
	_c.Call.Return(run)
	return _c
}

// RunAnalyzer provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) RunAnalyzer(_a0 context.Context, _a1 *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// RunAnalyzer is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.RunAnalyzerRequest
func (_e *MixCoord_Expecter) RunAnalyzer(_a0 interface{}, _a1 interface{}) *MixCoord_RunAnalyzer_Call {
	return &MixCoord_RunAnalyzer_Call{Call: _e.mock.On("RunAnalyzer", _a0, _a1)}
}

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

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

func (_c *MixCoord_RunAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error)) *MixCoord_RunAnalyzer_Call {
	_c.Call.Return(run)
	return _c
}

// SaveBinlogPaths provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// SelectGrant provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) SelectGrant(_a0 context.Context, _a1 *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// SelectGrant is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SelectGrantRequest
func (_e *MixCoord_Expecter) SelectGrant(_a0 interface{}, _a1 interface{}) *MixCoord_SelectGrant_Call {
	return &MixCoord_SelectGrant_Call{Call: _e.mock.On("SelectGrant", _a0, _a1)}
}

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

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

func (_c *MixCoord_SelectGrant_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)) *MixCoord_SelectGrant_Call {
	_c.Call.Return(run)
	return _c
}

// SelectRole provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) SelectRole(_a0 context.Context, _a1 *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// SelectRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SelectRoleRequest
func (_e *MixCoord_Expecter) SelectRole(_a0 interface{}, _a1 interface{}) *MixCoord_SelectRole_Call {
	return &MixCoord_SelectRole_Call{Call: _e.mock.On("SelectRole", _a0, _a1)}
}

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

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

func (_c *MixCoord_SelectRole_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error)) *MixCoord_SelectRole_Call {
	_c.Call.Return(run)
	return _c
}

// SelectUser provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) SelectUser(_a0 context.Context, _a1 *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// SelectUser is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SelectUserRequest
func (_e *MixCoord_Expecter) SelectUser(_a0 interface{}, _a1 interface{}) *MixCoord_SelectUser_Call {
	return &MixCoord_SelectUser_Call{Call: _e.mock.On("SelectUser", _a0, _a1)}
}

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

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

func (_c *MixCoord_SelectUser_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error)) *MixCoord_SelectUser_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

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

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

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

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

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

// SetMixCoordClient provides a mock function with given fields: client
func (_m *MixCoord) SetMixCoordClient(client types.MixCoordClient) {
	_m.Called(client)
}

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

// SetMixCoordClient is a helper method to define mock.On call
//   - client types.MixCoordClient
func (_e *MixCoord_Expecter) SetMixCoordClient(client interface{}) *MixCoord_SetMixCoordClient_Call {
	return &MixCoord_SetMixCoordClient_Call{Call: _e.mock.On("SetMixCoordClient", client)}
}

func (_c *MixCoord_SetMixCoordClient_Call) Run(run func(client types.MixCoordClient)) *MixCoord_SetMixCoordClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(types.MixCoordClient))
	})
	return _c
}

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

func (_c *MixCoord_SetMixCoordClient_Call) RunAndReturn(run func(types.MixCoordClient)) *MixCoord_SetMixCoordClient_Call {
	_c.Run(run)
	return _c
}

// SetSegmentState provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

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

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

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

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

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

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

// ShowCollectionIDs provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowCollectionIDs(_a0 context.Context, _a1 *rootcoordpb.ShowCollectionIDsRequest) (*rootcoordpb.ShowCollectionIDsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowCollectionIDs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *rootcoordpb.ShowCollectionIDsRequest
func (_e *MixCoord_Expecter) ShowCollectionIDs(_a0 interface{}, _a1 interface{}) *MixCoord_ShowCollectionIDs_Call {
	return &MixCoord_ShowCollectionIDs_Call{Call: _e.mock.On("ShowCollectionIDs", _a0, _a1)}
}

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

func (_c *MixCoord_ShowCollectionIDs_Call) Return(_a0 *rootcoordpb.ShowCollectionIDsResponse, _a1 error) *MixCoord_ShowCollectionIDs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_ShowCollectionIDs_Call) RunAndReturn(run func(context.Context, *rootcoordpb.ShowCollectionIDsRequest) (*rootcoordpb.ShowCollectionIDsResponse, error)) *MixCoord_ShowCollectionIDs_Call {
	_c.Call.Return(run)
	return _c
}

// ShowCollections provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowCollections(_a0 context.Context, _a1 *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowCollections is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ShowCollectionsRequest
func (_e *MixCoord_Expecter) ShowCollections(_a0 interface{}, _a1 interface{}) *MixCoord_ShowCollections_Call {
	return &MixCoord_ShowCollections_Call{Call: _e.mock.On("ShowCollections", _a0, _a1)}
}

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

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

func (_c *MixCoord_ShowCollections_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error)) *MixCoord_ShowCollections_Call {
	_c.Call.Return(run)
	return _c
}

// ShowConfigurations provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// ShowLoadCollections provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowLoadCollections(_a0 context.Context, _a1 *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowLoadCollections is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ShowCollectionsRequest
func (_e *MixCoord_Expecter) ShowLoadCollections(_a0 interface{}, _a1 interface{}) *MixCoord_ShowLoadCollections_Call {
	return &MixCoord_ShowLoadCollections_Call{Call: _e.mock.On("ShowLoadCollections", _a0, _a1)}
}

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

func (_c *MixCoord_ShowLoadCollections_Call) Return(_a0 *querypb.ShowCollectionsResponse, _a1 error) *MixCoord_ShowLoadCollections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_ShowLoadCollections_Call) RunAndReturn(run func(context.Context, *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error)) *MixCoord_ShowLoadCollections_Call {
	_c.Call.Return(run)
	return _c
}

// ShowLoadPartitions provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowLoadPartitions(_a0 context.Context, _a1 *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowLoadPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ShowPartitionsRequest
func (_e *MixCoord_Expecter) ShowLoadPartitions(_a0 interface{}, _a1 interface{}) *MixCoord_ShowLoadPartitions_Call {
	return &MixCoord_ShowLoadPartitions_Call{Call: _e.mock.On("ShowLoadPartitions", _a0, _a1)}
}

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

func (_c *MixCoord_ShowLoadPartitions_Call) Return(_a0 *querypb.ShowPartitionsResponse, _a1 error) *MixCoord_ShowLoadPartitions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MixCoord_ShowLoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error)) *MixCoord_ShowLoadPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPartitions provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowPartitions(_a0 context.Context, _a1 *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ShowPartitionsRequest
func (_e *MixCoord_Expecter) ShowPartitions(_a0 interface{}, _a1 interface{}) *MixCoord_ShowPartitions_Call {
	return &MixCoord_ShowPartitions_Call{Call: _e.mock.On("ShowPartitions", _a0, _a1)}
}

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

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

func (_c *MixCoord_ShowPartitions_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)) *MixCoord_ShowPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPartitionsInternal provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowPartitionsInternal(_a0 context.Context, _a1 *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowPartitionsInternal is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ShowPartitionsRequest
func (_e *MixCoord_Expecter) ShowPartitionsInternal(_a0 interface{}, _a1 interface{}) *MixCoord_ShowPartitionsInternal_Call {
	return &MixCoord_ShowPartitionsInternal_Call{Call: _e.mock.On("ShowPartitionsInternal", _a0, _a1)}
}

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

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

func (_c *MixCoord_ShowPartitionsInternal_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)) *MixCoord_ShowPartitionsInternal_Call {
	_c.Call.Return(run)
	return _c
}

// ShowSegments provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ShowSegments(_a0 context.Context, _a1 *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowSegments is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ShowSegmentsRequest
func (_e *MixCoord_Expecter) ShowSegments(_a0 interface{}, _a1 interface{}) *MixCoord_ShowSegments_Call {
	return &MixCoord_ShowSegments_Call{Call: _e.mock.On("ShowSegments", _a0, _a1)}
}

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

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

func (_c *MixCoord_ShowSegments_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)) *MixCoord_ShowSegments_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function with no fields
func (_m *MixCoord) 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
}

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

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

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

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

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

// Stop provides a mock function with no fields
func (_m *MixCoord) 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
}

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

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

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

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

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

// SuspendBalance provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) SuspendBalance(_a0 context.Context, _a1 *querypb.SuspendBalanceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendBalanceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendBalanceRequest) *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, *querypb.SuspendBalanceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SuspendBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.SuspendBalanceRequest
func (_e *MixCoord_Expecter) SuspendBalance(_a0 interface{}, _a1 interface{}) *MixCoord_SuspendBalance_Call {
	return &MixCoord_SuspendBalance_Call{Call: _e.mock.On("SuspendBalance", _a0, _a1)}
}

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

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

func (_c *MixCoord_SuspendBalance_Call) RunAndReturn(run func(context.Context, *querypb.SuspendBalanceRequest) (*commonpb.Status, error)) *MixCoord_SuspendBalance_Call {
	_c.Call.Return(run)
	return _c
}

// SuspendNode provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) SuspendNode(_a0 context.Context, _a1 *querypb.SuspendNodeRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendNodeRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendNodeRequest) *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, *querypb.SuspendNodeRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SuspendNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.SuspendNodeRequest
func (_e *MixCoord_Expecter) SuspendNode(_a0 interface{}, _a1 interface{}) *MixCoord_SuspendNode_Call {
	return &MixCoord_SuspendNode_Call{Call: _e.mock.On("SuspendNode", _a0, _a1)}
}

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

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

func (_c *MixCoord_SuspendNode_Call) RunAndReturn(run func(context.Context, *querypb.SuspendNodeRequest) (*commonpb.Status, error)) *MixCoord_SuspendNode_Call {
	_c.Call.Return(run)
	return _c
}

// SyncNewCreatedPartition provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) SyncNewCreatedPartition(_a0 context.Context, _a1 *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest) *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, *querypb.SyncNewCreatedPartitionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SyncNewCreatedPartition is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.SyncNewCreatedPartitionRequest
func (_e *MixCoord_Expecter) SyncNewCreatedPartition(_a0 interface{}, _a1 interface{}) *MixCoord_SyncNewCreatedPartition_Call {
	return &MixCoord_SyncNewCreatedPartition_Call{Call: _e.mock.On("SyncNewCreatedPartition", _a0, _a1)}
}

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

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

func (_c *MixCoord_SyncNewCreatedPartition_Call) RunAndReturn(run func(context.Context, *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error)) *MixCoord_SyncNewCreatedPartition_Call {
	_c.Call.Return(run)
	return _c
}

// SyncQcFileResource provides a mock function with given fields: ctx, resources, version
func (_m *MixCoord) SyncQcFileResource(ctx context.Context, resources []*internalpb.FileResourceInfo, version uint64) error {
	ret := _m.Called(ctx, resources, version)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*internalpb.FileResourceInfo, uint64) error); ok {
		r0 = rf(ctx, resources, version)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SyncQcFileResource is a helper method to define mock.On call
//   - ctx context.Context
//   - resources []*internalpb.FileResourceInfo
//   - version uint64
func (_e *MixCoord_Expecter) SyncQcFileResource(ctx interface{}, resources interface{}, version interface{}) *MixCoord_SyncQcFileResource_Call {
	return &MixCoord_SyncQcFileResource_Call{Call: _e.mock.On("SyncQcFileResource", ctx, resources, version)}
}

func (_c *MixCoord_SyncQcFileResource_Call) Run(run func(ctx context.Context, resources []*internalpb.FileResourceInfo, version uint64)) *MixCoord_SyncQcFileResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*internalpb.FileResourceInfo), args[2].(uint64))
	})
	return _c
}

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

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

// TransferChannel provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) TransferChannel(_a0 context.Context, _a1 *querypb.TransferChannelRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferChannelRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferChannelRequest) *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, *querypb.TransferChannelRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferChannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.TransferChannelRequest
func (_e *MixCoord_Expecter) TransferChannel(_a0 interface{}, _a1 interface{}) *MixCoord_TransferChannel_Call {
	return &MixCoord_TransferChannel_Call{Call: _e.mock.On("TransferChannel", _a0, _a1)}
}

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

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

func (_c *MixCoord_TransferChannel_Call) RunAndReturn(run func(context.Context, *querypb.TransferChannelRequest) (*commonpb.Status, error)) *MixCoord_TransferChannel_Call {
	_c.Call.Return(run)
	return _c
}

// TransferNode provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) TransferNode(_a0 context.Context, _a1 *milvuspb.TransferNodeRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) *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, *milvuspb.TransferNodeRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.TransferNodeRequest
func (_e *MixCoord_Expecter) TransferNode(_a0 interface{}, _a1 interface{}) *MixCoord_TransferNode_Call {
	return &MixCoord_TransferNode_Call{Call: _e.mock.On("TransferNode", _a0, _a1)}
}

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

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

func (_c *MixCoord_TransferNode_Call) RunAndReturn(run func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)) *MixCoord_TransferNode_Call {
	_c.Call.Return(run)
	return _c
}

// TransferReplica provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) TransferReplica(_a0 context.Context, _a1 *querypb.TransferReplicaRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest) *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, *querypb.TransferReplicaRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferReplica is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.TransferReplicaRequest
func (_e *MixCoord_Expecter) TransferReplica(_a0 interface{}, _a1 interface{}) *MixCoord_TransferReplica_Call {
	return &MixCoord_TransferReplica_Call{Call: _e.mock.On("TransferReplica", _a0, _a1)}
}

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

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

func (_c *MixCoord_TransferReplica_Call) RunAndReturn(run func(context.Context, *querypb.TransferReplicaRequest) (*commonpb.Status, error)) *MixCoord_TransferReplica_Call {
	_c.Call.Return(run)
	return _c
}

// TransferSegment provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) TransferSegment(_a0 context.Context, _a1 *querypb.TransferSegmentRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferSegmentRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferSegmentRequest) *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, *querypb.TransferSegmentRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferSegment is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.TransferSegmentRequest
func (_e *MixCoord_Expecter) TransferSegment(_a0 interface{}, _a1 interface{}) *MixCoord_TransferSegment_Call {
	return &MixCoord_TransferSegment_Call{Call: _e.mock.On("TransferSegment", _a0, _a1)}
}

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

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

func (_c *MixCoord_TransferSegment_Call) RunAndReturn(run func(context.Context, *querypb.TransferSegmentRequest) (*commonpb.Status, error)) *MixCoord_TransferSegment_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannelCheckpoint provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// UpdateChannelTimeTick provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) UpdateChannelTimeTick(_a0 context.Context, _a1 *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ChannelTimeTickMsg) *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, *internalpb.ChannelTimeTickMsg) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateChannelTimeTick is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.ChannelTimeTickMsg
func (_e *MixCoord_Expecter) UpdateChannelTimeTick(_a0 interface{}, _a1 interface{}) *MixCoord_UpdateChannelTimeTick_Call {
	return &MixCoord_UpdateChannelTimeTick_Call{Call: _e.mock.On("UpdateChannelTimeTick", _a0, _a1)}
}

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

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

func (_c *MixCoord_UpdateChannelTimeTick_Call) RunAndReturn(run func(context.Context, *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error)) *MixCoord_UpdateChannelTimeTick_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateCredential provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) UpdateCredential(_a0 context.Context, _a1 *internalpb.CredentialInfo) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) *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, *internalpb.CredentialInfo) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateCredential is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.CredentialInfo
func (_e *MixCoord_Expecter) UpdateCredential(_a0 interface{}, _a1 interface{}) *MixCoord_UpdateCredential_Call {
	return &MixCoord_UpdateCredential_Call{Call: _e.mock.On("UpdateCredential", _a0, _a1)}
}

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

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

func (_c *MixCoord_UpdateCredential_Call) RunAndReturn(run func(context.Context, *internalpb.CredentialInfo) (*commonpb.Status, error)) *MixCoord_UpdateCredential_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLoadConfig provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) UpdateLoadConfig(_a0 context.Context, _a1 *querypb.UpdateLoadConfigRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateLoadConfigRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateLoadConfigRequest) *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, *querypb.UpdateLoadConfigRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateLoadConfig is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.UpdateLoadConfigRequest
func (_e *MixCoord_Expecter) UpdateLoadConfig(_a0 interface{}, _a1 interface{}) *MixCoord_UpdateLoadConfig_Call {
	return &MixCoord_UpdateLoadConfig_Call{Call: _e.mock.On("UpdateLoadConfig", _a0, _a1)}
}

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

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

func (_c *MixCoord_UpdateLoadConfig_Call) RunAndReturn(run func(context.Context, *querypb.UpdateLoadConfigRequest) (*commonpb.Status, error)) *MixCoord_UpdateLoadConfig_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateResourceGroups provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) UpdateResourceGroups(_a0 context.Context, _a1 *querypb.UpdateResourceGroupsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateResourceGroupsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateResourceGroupsRequest) *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, *querypb.UpdateResourceGroupsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateResourceGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.UpdateResourceGroupsRequest
func (_e *MixCoord_Expecter) UpdateResourceGroups(_a0 interface{}, _a1 interface{}) *MixCoord_UpdateResourceGroups_Call {
	return &MixCoord_UpdateResourceGroups_Call{Call: _e.mock.On("UpdateResourceGroups", _a0, _a1)}
}

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

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

func (_c *MixCoord_UpdateResourceGroups_Call) RunAndReturn(run func(context.Context, *querypb.UpdateResourceGroupsRequest) (*commonpb.Status, error)) *MixCoord_UpdateResourceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSegmentStatistics provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

// UpdateStateCode provides a mock function with given fields: _a0
func (_m *MixCoord) UpdateStateCode(_a0 commonpb.StateCode) {
	_m.Called(_a0)
}

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

// UpdateStateCode is a helper method to define mock.On call
//   - _a0 commonpb.StateCode
func (_e *MixCoord_Expecter) UpdateStateCode(_a0 interface{}) *MixCoord_UpdateStateCode_Call {
	return &MixCoord_UpdateStateCode_Call{Call: _e.mock.On("UpdateStateCode", _a0)}
}

func (_c *MixCoord_UpdateStateCode_Call) Run(run func(_a0 commonpb.StateCode)) *MixCoord_UpdateStateCode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(commonpb.StateCode))
	})
	return _c
}

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

func (_c *MixCoord_UpdateStateCode_Call) RunAndReturn(run func(commonpb.StateCode)) *MixCoord_UpdateStateCode_Call {
	_c.Run(run)
	return _c
}

// ValidateAnalyzer provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) ValidateAnalyzer(_a0 context.Context, _a1 *querypb.ValidateAnalyzerRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ValidateAnalyzerRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ValidateAnalyzerRequest) *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, *querypb.ValidateAnalyzerRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ValidateAnalyzer is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ValidateAnalyzerRequest
func (_e *MixCoord_Expecter) ValidateAnalyzer(_a0 interface{}, _a1 interface{}) *MixCoord_ValidateAnalyzer_Call {
	return &MixCoord_ValidateAnalyzer_Call{Call: _e.mock.On("ValidateAnalyzer", _a0, _a1)}
}

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

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

func (_c *MixCoord_ValidateAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.ValidateAnalyzerRequest) (*commonpb.Status, error)) *MixCoord_ValidateAnalyzer_Call {
	_c.Call.Return(run)
	return _c
}

// WatchChannels provides a mock function with given fields: _a0, _a1
func (_m *MixCoord) 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
}

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

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

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

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

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

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

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

	return mock
}