milvus/internal/mocks/mock_mixcoord_client.go

// 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"

	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"

	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"
)

// MockMixCoordClient is an autogenerated mock type for the MixCoordClient type
type MockMixCoordClient struct {
	mock.Mock
}

type MockMixCoordClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMixCoordClient) EXPECT() *MockMixCoordClient_Expecter {
	return &MockMixCoordClient_Expecter{mock: &_m.Mock}
}

// ActivateChecker provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ActivateChecker(ctx context.Context, in *querypb.ActivateCheckerRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ActivateCheckerRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ActivateCheckerRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ActivateChecker is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ActivateCheckerRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ActivateChecker(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ActivateChecker_Call {
	return &MockMixCoordClient_ActivateChecker_Call{Call: _e.mock.On("ActivateChecker",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ActivateChecker_Call) Run(run func(ctx context.Context, in *querypb.ActivateCheckerRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ActivateChecker_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ActivateCheckerRequest), variadicArgs...)
	})
	return _c
}

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

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

// AddCollectionField provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AddCollectionField(ctx context.Context, in *milvuspb.AddCollectionFieldRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFieldRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFieldRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddCollectionField is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.AddCollectionFieldRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AddCollectionField(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AddCollectionField_Call {
	return &MockMixCoordClient_AddCollectionField_Call{Call: _e.mock.On("AddCollectionField",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AddCollectionField_Call) Run(run func(ctx context.Context, in *milvuspb.AddCollectionFieldRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AddCollectionField_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFieldRequest), variadicArgs...)
	})
	return _c
}

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

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

// AddFileResource provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AddFileResource(ctx context.Context, in *milvuspb.AddFileResourceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddFileResourceRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddFileResourceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddFileResource is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.AddFileResourceRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AddFileResource(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AddFileResource_Call {
	return &MockMixCoordClient_AddFileResource_Call{Call: _e.mock.On("AddFileResource",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AddFileResource_Call) Run(run func(ctx context.Context, in *milvuspb.AddFileResourceRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AddFileResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.AddFileResourceRequest), variadicArgs...)
	})
	return _c
}

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

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

// AllocID provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest, opts ...grpc.CallOption) (*rootcoordpb.AllocIDResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*rootcoordpb.AllocIDResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AllocIDRequest, ...grpc.CallOption) *rootcoordpb.AllocIDResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rootcoordpb.AllocIDResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.AllocIDRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AllocID is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.AllocIDRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AllocID(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AllocID_Call {
	return &MockMixCoordClient_AllocID_Call{Call: _e.mock.On("AllocID",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AllocID_Call) Run(run func(ctx context.Context, in *rootcoordpb.AllocIDRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AllocID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.AllocIDRequest), variadicArgs...)
	})
	return _c
}

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

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

// AllocSegment provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AllocSegment(ctx context.Context, in *datapb.AllocSegmentRequest, opts ...grpc.CallOption) (*datapb.AllocSegmentResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.AllocSegmentResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AllocSegmentRequest, ...grpc.CallOption) *datapb.AllocSegmentResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.AllocSegmentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.AllocSegmentRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AllocSegment is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.AllocSegmentRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AllocSegment(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AllocSegment_Call {
	return &MockMixCoordClient_AllocSegment_Call{Call: _e.mock.On("AllocSegment",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AllocSegment_Call) Run(run func(ctx context.Context, in *datapb.AllocSegmentRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AllocSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.AllocSegmentRequest), variadicArgs...)
	})
	return _c
}

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

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

// AllocTimestamp provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AllocTimestamp(ctx context.Context, in *rootcoordpb.AllocTimestampRequest, opts ...grpc.CallOption) (*rootcoordpb.AllocTimestampResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*rootcoordpb.AllocTimestampResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AllocTimestampRequest, ...grpc.CallOption) *rootcoordpb.AllocTimestampResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rootcoordpb.AllocTimestampResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.AllocTimestampRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AllocTimestamp is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.AllocTimestampRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AllocTimestamp(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AllocTimestamp_Call {
	return &MockMixCoordClient_AllocTimestamp_Call{Call: _e.mock.On("AllocTimestamp",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AllocTimestamp_Call) Run(run func(ctx context.Context, in *rootcoordpb.AllocTimestampRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AllocTimestamp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.AllocTimestampRequest), variadicArgs...)
	})
	return _c
}

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

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

// AlterAlias provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AlterAlias(ctx context.Context, in *milvuspb.AlterAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterAliasRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterAliasRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.AlterAliasRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AlterAlias(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterAlias_Call {
	return &MockMixCoordClient_AlterAlias_Call{Call: _e.mock.On("AlterAlias",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AlterAlias_Call) Run(run func(ctx context.Context, in *milvuspb.AlterAliasRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.AlterAliasRequest), variadicArgs...)
	})
	return _c
}

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

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

// AlterCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AlterCollection(ctx context.Context, in *milvuspb.AlterCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.AlterCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AlterCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterCollection_Call {
	return &MockMixCoordClient_AlterCollection_Call{Call: _e.mock.On("AlterCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AlterCollection_Call) Run(run func(ctx context.Context, in *milvuspb.AlterCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// AlterCollectionField provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AlterCollectionField(ctx context.Context, in *milvuspb.AlterCollectionFieldRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFieldRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFieldRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterCollectionField is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.AlterCollectionFieldRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AlterCollectionField(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterCollectionField_Call {
	return &MockMixCoordClient_AlterCollectionField_Call{Call: _e.mock.On("AlterCollectionField",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AlterCollectionField_Call) Run(run func(ctx context.Context, in *milvuspb.AlterCollectionFieldRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterCollectionField_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFieldRequest), variadicArgs...)
	})
	return _c
}

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

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

// AlterDatabase provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AlterDatabaseRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.AlterDatabaseRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.AlterDatabaseRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AlterDatabase(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterDatabase_Call {
	return &MockMixCoordClient_AlterDatabase_Call{Call: _e.mock.On("AlterDatabase",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AlterDatabase_Call) Run(run func(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.AlterDatabaseRequest), variadicArgs...)
	})
	return _c
}

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

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

// AlterIndex provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AlterIndex(ctx context.Context, in *indexpb.AlterIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.AlterIndexRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.AlterIndexRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AlterIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.AlterIndexRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AlterIndex(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterIndex_Call {
	return &MockMixCoordClient_AlterIndex_Call{Call: _e.mock.On("AlterIndex",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AlterIndex_Call) Run(run func(ctx context.Context, in *indexpb.AlterIndexRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.AlterIndexRequest), variadicArgs...)
	})
	return _c
}

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

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

// AssignSegmentID provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) AssignSegmentID(ctx context.Context, in *datapb.AssignSegmentIDRequest, opts ...grpc.CallOption) (*datapb.AssignSegmentIDResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.AssignSegmentIDResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AssignSegmentIDRequest, ...grpc.CallOption) *datapb.AssignSegmentIDResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.AssignSegmentIDResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.AssignSegmentIDRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AssignSegmentID is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.AssignSegmentIDRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) AssignSegmentID(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AssignSegmentID_Call {
	return &MockMixCoordClient_AssignSegmentID_Call{Call: _e.mock.On("AssignSegmentID",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_AssignSegmentID_Call) Run(run func(ctx context.Context, in *datapb.AssignSegmentIDRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AssignSegmentID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.AssignSegmentIDRequest), variadicArgs...)
	})
	return _c
}

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

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

// BackupRBAC provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) BackupRBAC(ctx context.Context, in *milvuspb.BackupRBACMetaRequest, opts ...grpc.CallOption) (*milvuspb.BackupRBACMetaResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.BackupRBACMetaResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.BackupRBACMetaRequest, ...grpc.CallOption) *milvuspb.BackupRBACMetaResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.BackupRBACMetaResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.BackupRBACMetaRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// BackupRBAC is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.BackupRBACMetaRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) BackupRBAC(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_BackupRBAC_Call {
	return &MockMixCoordClient_BackupRBAC_Call{Call: _e.mock.On("BackupRBAC",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_BackupRBAC_Call) Run(run func(ctx context.Context, in *milvuspb.BackupRBACMetaRequest, opts ...grpc.CallOption)) *MockMixCoordClient_BackupRBAC_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.BackupRBACMetaRequest), variadicArgs...)
	})
	return _c
}

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

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

// BroadcastAlteredCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) BroadcastAlteredCollection(ctx context.Context, in *datapb.AlterCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.AlterCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// BroadcastAlteredCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.AlterCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) BroadcastAlteredCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_BroadcastAlteredCollection_Call {
	return &MockMixCoordClient_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, in *datapb.AlterCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_BroadcastAlteredCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.AlterCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// CheckBalanceStatus provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CheckBalanceStatus(ctx context.Context, in *querypb.CheckBalanceStatusRequest, opts ...grpc.CallOption) (*querypb.CheckBalanceStatusResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.CheckBalanceStatusResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckBalanceStatusRequest, ...grpc.CallOption) *querypb.CheckBalanceStatusResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.CheckBalanceStatusResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.CheckBalanceStatusRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CheckBalanceStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.CheckBalanceStatusRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CheckBalanceStatus(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CheckBalanceStatus_Call {
	return &MockMixCoordClient_CheckBalanceStatus_Call{Call: _e.mock.On("CheckBalanceStatus",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CheckBalanceStatus_Call) Run(run func(ctx context.Context, in *querypb.CheckBalanceStatusRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CheckBalanceStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.CheckBalanceStatusRequest), variadicArgs...)
	})
	return _c
}

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

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

// CheckHealth provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest, ...grpc.CallOption) *milvuspb.CheckHealthResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CheckHealth is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CheckHealthRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CheckHealth(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CheckHealth_Call {
	return &MockMixCoordClient_CheckHealth_Call{Call: _e.mock.On("CheckHealth",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CheckHealth_Call) Run(run func(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CheckHealth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest), variadicArgs...)
	})
	return _c
}

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

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

// CheckQueryNodeDistribution provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CheckQueryNodeDistribution(ctx context.Context, in *querypb.CheckQueryNodeDistributionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckQueryNodeDistributionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.CheckQueryNodeDistributionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CheckQueryNodeDistribution is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.CheckQueryNodeDistributionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CheckQueryNodeDistribution(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CheckQueryNodeDistribution_Call {
	return &MockMixCoordClient_CheckQueryNodeDistribution_Call{Call: _e.mock.On("CheckQueryNodeDistribution",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CheckQueryNodeDistribution_Call) Run(run func(ctx context.Context, in *querypb.CheckQueryNodeDistributionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CheckQueryNodeDistribution_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.CheckQueryNodeDistributionRequest), variadicArgs...)
	})
	return _c
}

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

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

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

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

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

	return r0
}

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

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

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

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

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

// CreateAlias provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateAlias(ctx context.Context, in *milvuspb.CreateAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateAliasRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateAliasRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreateAliasRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateAlias(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateAlias_Call {
	return &MockMixCoordClient_CreateAlias_Call{Call: _e.mock.On("CreateAlias",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateAlias_Call) Run(run func(ctx context.Context, in *milvuspb.CreateAliasRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreateAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreateAliasRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreateCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateCollection(ctx context.Context, in *milvuspb.CreateCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreateCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateCollection_Call {
	return &MockMixCoordClient_CreateCollection_Call{Call: _e.mock.On("CreateCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateCollection_Call) Run(run func(ctx context.Context, in *milvuspb.CreateCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreateCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreateCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreateCredential provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateCredential(ctx context.Context, in *internalpb.CredentialInfo, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.CredentialInfo, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.CredentialInfo
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateCredential(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateCredential_Call {
	return &MockMixCoordClient_CreateCredential_Call{Call: _e.mock.On("CreateCredential",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateCredential_Call) Run(run func(ctx context.Context, in *internalpb.CredentialInfo, opts ...grpc.CallOption)) *MockMixCoordClient_CreateCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.CredentialInfo), variadicArgs...)
	})
	return _c
}

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

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

// CreateDatabase provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateDatabase(ctx context.Context, in *milvuspb.CreateDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateDatabaseRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateDatabaseRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreateDatabaseRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateDatabase(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateDatabase_Call {
	return &MockMixCoordClient_CreateDatabase_Call{Call: _e.mock.On("CreateDatabase",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateDatabase_Call) Run(run func(ctx context.Context, in *milvuspb.CreateDatabaseRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreateDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreateDatabaseRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreateIndex provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateIndex(ctx context.Context, in *indexpb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.CreateIndexRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.CreateIndexRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateIndex(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateIndex_Call {
	return &MockMixCoordClient_CreateIndex_Call{Call: _e.mock.On("CreateIndex",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateIndex_Call) Run(run func(ctx context.Context, in *indexpb.CreateIndexRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreateIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.CreateIndexRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreatePartition provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePartitionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreatePartitionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreatePartition is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreatePartitionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreatePartition(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreatePartition_Call {
	return &MockMixCoordClient_CreatePartition_Call{Call: _e.mock.On("CreatePartition",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreatePartition_Call) Run(run func(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreatePartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreatePartitionRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreatePrivilegeGroup provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreatePrivilegeGroup(ctx context.Context, in *milvuspb.CreatePrivilegeGroupRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePrivilegeGroupRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreatePrivilegeGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreatePrivilegeGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreatePrivilegeGroupRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreatePrivilegeGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreatePrivilegeGroup_Call {
	return &MockMixCoordClient_CreatePrivilegeGroup_Call{Call: _e.mock.On("CreatePrivilegeGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreatePrivilegeGroup_Call) Run(run func(ctx context.Context, in *milvuspb.CreatePrivilegeGroupRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreatePrivilegeGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreatePrivilegeGroupRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreateResourceGroup provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateResourceGroup(ctx context.Context, in *milvuspb.CreateResourceGroupRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateResourceGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateResourceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreateResourceGroupRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateResourceGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateResourceGroup_Call {
	return &MockMixCoordClient_CreateResourceGroup_Call{Call: _e.mock.On("CreateResourceGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateResourceGroup_Call) Run(run func(ctx context.Context, in *milvuspb.CreateResourceGroupRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreateResourceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreateResourceGroupRequest), variadicArgs...)
	})
	return _c
}

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

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

// CreateRole provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) CreateRole(ctx context.Context, in *milvuspb.CreateRoleRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateRoleRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateRoleRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.CreateRoleRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) CreateRole(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_CreateRole_Call {
	return &MockMixCoordClient_CreateRole_Call{Call: _e.mock.On("CreateRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_CreateRole_Call) Run(run func(ctx context.Context, in *milvuspb.CreateRoleRequest, opts ...grpc.CallOption)) *MockMixCoordClient_CreateRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.CreateRoleRequest), variadicArgs...)
	})
	return _c
}

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

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

// DeactivateChecker provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DeactivateChecker(ctx context.Context, in *querypb.DeactivateCheckerRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeactivateCheckerRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.DeactivateCheckerRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeactivateChecker is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.DeactivateCheckerRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DeactivateChecker(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DeactivateChecker_Call {
	return &MockMixCoordClient_DeactivateChecker_Call{Call: _e.mock.On("DeactivateChecker",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DeactivateChecker_Call) Run(run func(ctx context.Context, in *querypb.DeactivateCheckerRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DeactivateChecker_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.DeactivateCheckerRequest), variadicArgs...)
	})
	return _c
}

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

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

// DeleteCredential provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DeleteCredential(ctx context.Context, in *milvuspb.DeleteCredentialRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DeleteCredentialRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DeleteCredentialRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DeleteCredentialRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DeleteCredential(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DeleteCredential_Call {
	return &MockMixCoordClient_DeleteCredential_Call{Call: _e.mock.On("DeleteCredential",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DeleteCredential_Call) Run(run func(ctx context.Context, in *milvuspb.DeleteCredentialRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DeleteCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DeleteCredentialRequest), variadicArgs...)
	})
	return _c
}

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

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

// DescribeAlias provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DescribeAlias(ctx context.Context, in *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeAliasRequest, ...grpc.CallOption) *milvuspb.DescribeAliasResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.DescribeAliasResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeAliasRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DescribeAliasRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DescribeAlias(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DescribeAlias_Call {
	return &MockMixCoordClient_DescribeAlias_Call{Call: _e.mock.On("DescribeAlias",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DescribeAlias_Call) Run(run func(ctx context.Context, in *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DescribeAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DescribeAliasRequest), variadicArgs...)
	})
	return _c
}

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

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

// DescribeCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeCollectionRequest, ...grpc.CallOption) *milvuspb.DescribeCollectionResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.DescribeCollectionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DescribeCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DescribeCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DescribeCollection_Call {
	return &MockMixCoordClient_DescribeCollection_Call{Call: _e.mock.On("DescribeCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DescribeCollection_Call) Run(run func(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DescribeCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DescribeCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// DescribeCollectionInternal provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DescribeCollectionInternal(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeCollectionRequest, ...grpc.CallOption) *milvuspb.DescribeCollectionResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.DescribeCollectionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeCollectionInternal is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DescribeCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DescribeCollectionInternal(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DescribeCollectionInternal_Call {
	return &MockMixCoordClient_DescribeCollectionInternal_Call{Call: _e.mock.On("DescribeCollectionInternal",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DescribeCollectionInternal_Call) Run(run func(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DescribeCollectionInternal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DescribeCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// DescribeDatabase provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DescribeDatabase(ctx context.Context, in *rootcoordpb.DescribeDatabaseRequest, opts ...grpc.CallOption) (*rootcoordpb.DescribeDatabaseResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*rootcoordpb.DescribeDatabaseResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.DescribeDatabaseRequest, ...grpc.CallOption) *rootcoordpb.DescribeDatabaseResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rootcoordpb.DescribeDatabaseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.DescribeDatabaseRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.DescribeDatabaseRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DescribeDatabase(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DescribeDatabase_Call {
	return &MockMixCoordClient_DescribeDatabase_Call{Call: _e.mock.On("DescribeDatabase",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DescribeDatabase_Call) Run(run func(ctx context.Context, in *rootcoordpb.DescribeDatabaseRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DescribeDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.DescribeDatabaseRequest), variadicArgs...)
	})
	return _c
}

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

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

// DescribeIndex provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DescribeIndex(ctx context.Context, in *indexpb.DescribeIndexRequest, opts ...grpc.CallOption) (*indexpb.DescribeIndexResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.DescribeIndexResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest, ...grpc.CallOption) *indexpb.DescribeIndexResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.DescribeIndexResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DescribeIndexRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.DescribeIndexRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DescribeIndex(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DescribeIndex_Call {
	return &MockMixCoordClient_DescribeIndex_Call{Call: _e.mock.On("DescribeIndex",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DescribeIndex_Call) Run(run func(ctx context.Context, in *indexpb.DescribeIndexRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DescribeIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.DescribeIndexRequest), variadicArgs...)
	})
	return _c
}

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

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

// DescribeResourceGroup provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DescribeResourceGroup(ctx context.Context, in *querypb.DescribeResourceGroupRequest, opts ...grpc.CallOption) (*querypb.DescribeResourceGroupResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.DescribeResourceGroupResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.DescribeResourceGroupRequest, ...grpc.CallOption) *querypb.DescribeResourceGroupResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.DescribeResourceGroupResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.DescribeResourceGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeResourceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.DescribeResourceGroupRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DescribeResourceGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DescribeResourceGroup_Call {
	return &MockMixCoordClient_DescribeResourceGroup_Call{Call: _e.mock.On("DescribeResourceGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DescribeResourceGroup_Call) Run(run func(ctx context.Context, in *querypb.DescribeResourceGroupRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DescribeResourceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.DescribeResourceGroupRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropAlias provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropAlias(ctx context.Context, in *milvuspb.DropAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropAliasRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropAliasRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropAliasRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropAlias(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropAlias_Call {
	return &MockMixCoordClient_DropAlias_Call{Call: _e.mock.On("DropAlias",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropAlias_Call) Run(run func(ctx context.Context, in *milvuspb.DropAliasRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropAliasRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropCollection(ctx context.Context, in *milvuspb.DropCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropCollection_Call {
	return &MockMixCoordClient_DropCollection_Call{Call: _e.mock.On("DropCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropCollection_Call) Run(run func(ctx context.Context, in *milvuspb.DropCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropDatabase provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropDatabase(ctx context.Context, in *milvuspb.DropDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropDatabaseRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropDatabaseRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropDatabaseRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropDatabase(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropDatabase_Call {
	return &MockMixCoordClient_DropDatabase_Call{Call: _e.mock.On("DropDatabase",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropDatabase_Call) Run(run func(ctx context.Context, in *milvuspb.DropDatabaseRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropDatabaseRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropIndex provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropIndex(ctx context.Context, in *indexpb.DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DropIndexRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.DropIndexRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropIndex(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropIndex_Call {
	return &MockMixCoordClient_DropIndex_Call{Call: _e.mock.On("DropIndex",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropIndex_Call) Run(run func(ctx context.Context, in *indexpb.DropIndexRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.DropIndexRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropPartition provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropPartition(ctx context.Context, in *milvuspb.DropPartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPartitionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropPartitionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropPartition is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropPartitionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropPartition(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropPartition_Call {
	return &MockMixCoordClient_DropPartition_Call{Call: _e.mock.On("DropPartition",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropPartition_Call) Run(run func(ctx context.Context, in *milvuspb.DropPartitionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropPartitionRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropPrivilegeGroup provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropPrivilegeGroup(ctx context.Context, in *milvuspb.DropPrivilegeGroupRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPrivilegeGroupRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropPrivilegeGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropPrivilegeGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropPrivilegeGroupRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropPrivilegeGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropPrivilegeGroup_Call {
	return &MockMixCoordClient_DropPrivilegeGroup_Call{Call: _e.mock.On("DropPrivilegeGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropPrivilegeGroup_Call) Run(run func(ctx context.Context, in *milvuspb.DropPrivilegeGroupRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropPrivilegeGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropPrivilegeGroupRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropResourceGroup provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropResourceGroup(ctx context.Context, in *milvuspb.DropResourceGroupRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropResourceGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropResourceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropResourceGroupRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropResourceGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropResourceGroup_Call {
	return &MockMixCoordClient_DropResourceGroup_Call{Call: _e.mock.On("DropResourceGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropResourceGroup_Call) Run(run func(ctx context.Context, in *milvuspb.DropResourceGroupRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropResourceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropResourceGroupRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropRole provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropRole(ctx context.Context, in *milvuspb.DropRoleRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropRoleRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropRoleRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.DropRoleRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropRole(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropRole_Call {
	return &MockMixCoordClient_DropRole_Call{Call: _e.mock.On("DropRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropRole_Call) Run(run func(ctx context.Context, in *milvuspb.DropRoleRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.DropRoleRequest), variadicArgs...)
	})
	return _c
}

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

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

// DropVirtualChannel provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) DropVirtualChannel(ctx context.Context, in *datapb.DropVirtualChannelRequest, opts ...grpc.CallOption) (*datapb.DropVirtualChannelResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.DropVirtualChannelResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropVirtualChannelRequest, ...grpc.CallOption) *datapb.DropVirtualChannelResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.DropVirtualChannelResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.DropVirtualChannelRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DropVirtualChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.DropVirtualChannelRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) DropVirtualChannel(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropVirtualChannel_Call {
	return &MockMixCoordClient_DropVirtualChannel_Call{Call: _e.mock.On("DropVirtualChannel",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_DropVirtualChannel_Call) Run(run func(ctx context.Context, in *datapb.DropVirtualChannelRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropVirtualChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.DropVirtualChannelRequest), variadicArgs...)
	})
	return _c
}

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

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

// Flush provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) Flush(ctx context.Context, in *datapb.FlushRequest, opts ...grpc.CallOption) (*datapb.FlushResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.FlushResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushRequest, ...grpc.CallOption) *datapb.FlushResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.FlushResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.FlushRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Flush is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.FlushRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) Flush(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_Flush_Call {
	return &MockMixCoordClient_Flush_Call{Call: _e.mock.On("Flush",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_Flush_Call) Run(run func(ctx context.Context, in *datapb.FlushRequest, opts ...grpc.CallOption)) *MockMixCoordClient_Flush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.FlushRequest), variadicArgs...)
	})
	return _c
}

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

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

// FlushAll provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) FlushAll(ctx context.Context, in *datapb.FlushAllRequest, opts ...grpc.CallOption) (*datapb.FlushAllResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.FlushAllResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushAllRequest, ...grpc.CallOption) *datapb.FlushAllResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.FlushAllResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.FlushAllRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FlushAll is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.FlushAllRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) FlushAll(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_FlushAll_Call {
	return &MockMixCoordClient_FlushAll_Call{Call: _e.mock.On("FlushAll",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_FlushAll_Call) Run(run func(ctx context.Context, in *datapb.FlushAllRequest, opts ...grpc.CallOption)) *MockMixCoordClient_FlushAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.FlushAllRequest), variadicArgs...)
	})
	return _c
}

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

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

// GcConfirm provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GcConfirm(ctx context.Context, in *datapb.GcConfirmRequest, opts ...grpc.CallOption) (*datapb.GcConfirmResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GcConfirmResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest, ...grpc.CallOption) *datapb.GcConfirmResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GcConfirmResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcConfirmRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GcConfirm is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GcConfirmRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GcConfirm(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GcConfirm_Call {
	return &MockMixCoordClient_GcConfirm_Call{Call: _e.mock.On("GcConfirm",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GcConfirm_Call) Run(run func(ctx context.Context, in *datapb.GcConfirmRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GcConfirm_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GcConfirmRequest), variadicArgs...)
	})
	return _c
}

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

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

// GcControl provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GcControl(ctx context.Context, in *datapb.GcControlRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcControlRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcControlRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GcControl is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GcControlRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GcControl(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GcControl_Call {
	return &MockMixCoordClient_GcControl_Call{Call: _e.mock.On("GcControl",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GcControl_Call) Run(run func(ctx context.Context, in *datapb.GcControlRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GcControl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GcControlRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetChannelRecoveryInfo provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetChannelRecoveryInfo(ctx context.Context, in *datapb.GetChannelRecoveryInfoRequest, opts ...grpc.CallOption) (*datapb.GetChannelRecoveryInfoResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetChannelRecoveryInfoResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetChannelRecoveryInfoRequest, ...grpc.CallOption) *datapb.GetChannelRecoveryInfoResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetChannelRecoveryInfoResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetChannelRecoveryInfoRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetChannelRecoveryInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetChannelRecoveryInfoRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetChannelRecoveryInfo(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetChannelRecoveryInfo_Call {
	return &MockMixCoordClient_GetChannelRecoveryInfo_Call{Call: _e.mock.On("GetChannelRecoveryInfo",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetChannelRecoveryInfo_Call) Run(run func(ctx context.Context, in *datapb.GetChannelRecoveryInfoRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetChannelRecoveryInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetChannelRecoveryInfoRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetCollectionStatistics provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetCollectionStatistics(ctx context.Context, in *datapb.GetCollectionStatisticsRequest, opts ...grpc.CallOption) (*datapb.GetCollectionStatisticsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetCollectionStatisticsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetCollectionStatisticsRequest, ...grpc.CallOption) *datapb.GetCollectionStatisticsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetCollectionStatisticsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetCollectionStatisticsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetCollectionStatistics is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetCollectionStatisticsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetCollectionStatistics(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetCollectionStatistics_Call {
	return &MockMixCoordClient_GetCollectionStatistics_Call{Call: _e.mock.On("GetCollectionStatistics",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetCollectionStatistics_Call) Run(run func(ctx context.Context, in *datapb.GetCollectionStatisticsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetCollectionStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetCollectionStatisticsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetCompactionState provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetCompactionState(ctx context.Context, in *milvuspb.GetCompactionStateRequest, opts ...grpc.CallOption) (*milvuspb.GetCompactionStateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.GetCompactionStateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionStateRequest, ...grpc.CallOption) *milvuspb.GetCompactionStateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetCompactionStateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionStateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetCompactionState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.GetCompactionStateRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetCompactionState(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetCompactionState_Call {
	return &MockMixCoordClient_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetCompactionState_Call) Run(run func(ctx context.Context, in *milvuspb.GetCompactionStateRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetCompactionState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionStateRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetCompactionStateWithPlans provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetCompactionStateWithPlans(ctx context.Context, in *milvuspb.GetCompactionPlansRequest, opts ...grpc.CallOption) (*milvuspb.GetCompactionPlansResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.GetCompactionPlansResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionPlansRequest, ...grpc.CallOption) *milvuspb.GetCompactionPlansResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetCompactionPlansResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionPlansRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetCompactionStateWithPlans is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.GetCompactionPlansRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetCompactionStateWithPlans(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetCompactionStateWithPlans_Call {
	return &MockMixCoordClient_GetCompactionStateWithPlans_Call{Call: _e.mock.On("GetCompactionStateWithPlans",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetCompactionStateWithPlans_Call) Run(run func(ctx context.Context, in *milvuspb.GetCompactionPlansRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetCompactionStateWithPlans_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionPlansRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetComponentStates provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ComponentStates, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetComponentStatesRequest, ...grpc.CallOption) *milvuspb.ComponentStates); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ComponentStates)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetComponentStatesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetComponentStates is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.GetComponentStatesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetComponentStates(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetComponentStates_Call {
	return &MockMixCoordClient_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetComponentStates_Call) Run(run func(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetComponentStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.GetComponentStatesRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetCredential provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetCredential(ctx context.Context, in *rootcoordpb.GetCredentialRequest, opts ...grpc.CallOption) (*rootcoordpb.GetCredentialResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*rootcoordpb.GetCredentialResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.GetCredentialRequest, ...grpc.CallOption) *rootcoordpb.GetCredentialResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rootcoordpb.GetCredentialResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.GetCredentialRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.GetCredentialRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetCredential(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetCredential_Call {
	return &MockMixCoordClient_GetCredential_Call{Call: _e.mock.On("GetCredential",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetCredential_Call) Run(run func(ctx context.Context, in *rootcoordpb.GetCredentialRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.GetCredentialRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetFlushAllState provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetFlushAllState(ctx context.Context, in *milvuspb.GetFlushAllStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushAllStateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.GetFlushAllStateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushAllStateRequest, ...grpc.CallOption) *milvuspb.GetFlushAllStateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetFlushAllStateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetFlushAllStateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFlushAllState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.GetFlushAllStateRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetFlushAllState(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetFlushAllState_Call {
	return &MockMixCoordClient_GetFlushAllState_Call{Call: _e.mock.On("GetFlushAllState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetFlushAllState_Call) Run(run func(ctx context.Context, in *milvuspb.GetFlushAllStateRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetFlushAllState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.GetFlushAllStateRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetFlushState provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetFlushState(ctx context.Context, in *datapb.GetFlushStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushStateRequest, ...grpc.CallOption) *milvuspb.GetFlushStateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetFlushStateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetFlushStateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFlushState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetFlushStateRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetFlushState(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetFlushState_Call {
	return &MockMixCoordClient_GetFlushState_Call{Call: _e.mock.On("GetFlushState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetFlushState_Call) Run(run func(ctx context.Context, in *datapb.GetFlushStateRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetFlushState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetFlushStateRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetFlushedSegments provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetFlushedSegments(ctx context.Context, in *datapb.GetFlushedSegmentsRequest, opts ...grpc.CallOption) (*datapb.GetFlushedSegmentsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetFlushedSegmentsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushedSegmentsRequest, ...grpc.CallOption) *datapb.GetFlushedSegmentsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetFlushedSegmentsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetFlushedSegmentsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFlushedSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetFlushedSegmentsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetFlushedSegments(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetFlushedSegments_Call {
	return &MockMixCoordClient_GetFlushedSegments_Call{Call: _e.mock.On("GetFlushedSegments",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetFlushedSegments_Call) Run(run func(ctx context.Context, in *datapb.GetFlushedSegmentsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetFlushedSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetFlushedSegmentsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetImportProgress provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetImportProgress(ctx context.Context, in *internalpb.GetImportProgressRequest, opts ...grpc.CallOption) (*internalpb.GetImportProgressResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*internalpb.GetImportProgressResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetImportProgressRequest, ...grpc.CallOption) *internalpb.GetImportProgressResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.GetImportProgressResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetImportProgressRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetImportProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.GetImportProgressRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetImportProgress(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetImportProgress_Call {
	return &MockMixCoordClient_GetImportProgress_Call{Call: _e.mock.On("GetImportProgress",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetImportProgress_Call) Run(run func(ctx context.Context, in *internalpb.GetImportProgressRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetImportProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.GetImportProgressRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetIndexBuildProgress provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetIndexBuildProgress(ctx context.Context, in *indexpb.GetIndexBuildProgressRequest, opts ...grpc.CallOption) (*indexpb.GetIndexBuildProgressResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.GetIndexBuildProgressResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest, ...grpc.CallOption) *indexpb.GetIndexBuildProgressResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.GetIndexBuildProgressResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexBuildProgressRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetIndexBuildProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.GetIndexBuildProgressRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetIndexBuildProgress(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetIndexBuildProgress_Call {
	return &MockMixCoordClient_GetIndexBuildProgress_Call{Call: _e.mock.On("GetIndexBuildProgress",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetIndexBuildProgress_Call) Run(run func(ctx context.Context, in *indexpb.GetIndexBuildProgressRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetIndexBuildProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.GetIndexBuildProgressRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetIndexInfos provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetIndexInfos(ctx context.Context, in *indexpb.GetIndexInfoRequest, opts ...grpc.CallOption) (*indexpb.GetIndexInfoResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.GetIndexInfoResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest, ...grpc.CallOption) *indexpb.GetIndexInfoResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.GetIndexInfoResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexInfoRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetIndexInfos is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.GetIndexInfoRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetIndexInfos(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetIndexInfos_Call {
	return &MockMixCoordClient_GetIndexInfos_Call{Call: _e.mock.On("GetIndexInfos",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetIndexInfos_Call) Run(run func(ctx context.Context, in *indexpb.GetIndexInfoRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetIndexInfos_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.GetIndexInfoRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetIndexState provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetIndexState(ctx context.Context, in *indexpb.GetIndexStateRequest, opts ...grpc.CallOption) (*indexpb.GetIndexStateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.GetIndexStateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest, ...grpc.CallOption) *indexpb.GetIndexStateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.GetIndexStateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetIndexState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.GetIndexStateRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetIndexState(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetIndexState_Call {
	return &MockMixCoordClient_GetIndexState_Call{Call: _e.mock.On("GetIndexState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetIndexState_Call) Run(run func(ctx context.Context, in *indexpb.GetIndexStateRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetIndexState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.GetIndexStateRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetIndexStatistics provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetIndexStatistics(ctx context.Context, in *indexpb.GetIndexStatisticsRequest, opts ...grpc.CallOption) (*indexpb.GetIndexStatisticsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.GetIndexStatisticsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStatisticsRequest, ...grpc.CallOption) *indexpb.GetIndexStatisticsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.GetIndexStatisticsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStatisticsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetIndexStatistics is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.GetIndexStatisticsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetIndexStatistics(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetIndexStatistics_Call {
	return &MockMixCoordClient_GetIndexStatistics_Call{Call: _e.mock.On("GetIndexStatistics",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetIndexStatistics_Call) Run(run func(ctx context.Context, in *indexpb.GetIndexStatisticsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetIndexStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.GetIndexStatisticsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetInsertBinlogPaths provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetInsertBinlogPaths(ctx context.Context, in *datapb.GetInsertBinlogPathsRequest, opts ...grpc.CallOption) (*datapb.GetInsertBinlogPathsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetInsertBinlogPathsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetInsertBinlogPathsRequest, ...grpc.CallOption) *datapb.GetInsertBinlogPathsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetInsertBinlogPathsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetInsertBinlogPathsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetInsertBinlogPaths is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetInsertBinlogPathsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetInsertBinlogPaths(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetInsertBinlogPaths_Call {
	return &MockMixCoordClient_GetInsertBinlogPaths_Call{Call: _e.mock.On("GetInsertBinlogPaths",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetInsertBinlogPaths_Call) Run(run func(ctx context.Context, in *datapb.GetInsertBinlogPathsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetInsertBinlogPaths_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetInsertBinlogPathsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetLoadSegmentInfo provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetLoadSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest, opts ...grpc.CallOption) (*querypb.GetSegmentInfoResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.GetSegmentInfoResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest, ...grpc.CallOption) *querypb.GetSegmentInfoResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.GetSegmentInfoResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetSegmentInfoRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLoadSegmentInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.GetSegmentInfoRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetLoadSegmentInfo(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetLoadSegmentInfo_Call {
	return &MockMixCoordClient_GetLoadSegmentInfo_Call{Call: _e.mock.On("GetLoadSegmentInfo",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetLoadSegmentInfo_Call) Run(run func(ctx context.Context, in *querypb.GetSegmentInfoRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetLoadSegmentInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.GetSegmentInfoRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetMetrics provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest, ...grpc.CallOption) *milvuspb.GetMetricsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetMetricsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.GetMetricsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetMetrics(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetMetrics_Call {
	return &MockMixCoordClient_GetMetrics_Call{Call: _e.mock.On("GetMetrics",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetMetrics_Call) Run(run func(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetMetrics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetPChannelInfo provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetPChannelInfo(ctx context.Context, in *rootcoordpb.GetPChannelInfoRequest, opts ...grpc.CallOption) (*rootcoordpb.GetPChannelInfoResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*rootcoordpb.GetPChannelInfoResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.GetPChannelInfoRequest, ...grpc.CallOption) *rootcoordpb.GetPChannelInfoResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rootcoordpb.GetPChannelInfoResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.GetPChannelInfoRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPChannelInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.GetPChannelInfoRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetPChannelInfo(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetPChannelInfo_Call {
	return &MockMixCoordClient_GetPChannelInfo_Call{Call: _e.mock.On("GetPChannelInfo",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetPChannelInfo_Call) Run(run func(ctx context.Context, in *rootcoordpb.GetPChannelInfoRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetPChannelInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.GetPChannelInfoRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetPartitionStates provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetPartitionStates(ctx context.Context, in *querypb.GetPartitionStatesRequest, opts ...grpc.CallOption) (*querypb.GetPartitionStatesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.GetPartitionStatesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetPartitionStatesRequest, ...grpc.CallOption) *querypb.GetPartitionStatesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.GetPartitionStatesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetPartitionStatesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPartitionStates is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.GetPartitionStatesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetPartitionStates(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetPartitionStates_Call {
	return &MockMixCoordClient_GetPartitionStates_Call{Call: _e.mock.On("GetPartitionStates",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetPartitionStates_Call) Run(run func(ctx context.Context, in *querypb.GetPartitionStatesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetPartitionStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.GetPartitionStatesRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetPartitionStatistics provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetPartitionStatistics(ctx context.Context, in *datapb.GetPartitionStatisticsRequest, opts ...grpc.CallOption) (*datapb.GetPartitionStatisticsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetPartitionStatisticsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetPartitionStatisticsRequest, ...grpc.CallOption) *datapb.GetPartitionStatisticsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetPartitionStatisticsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetPartitionStatisticsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPartitionStatistics is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetPartitionStatisticsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetPartitionStatistics(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetPartitionStatistics_Call {
	return &MockMixCoordClient_GetPartitionStatistics_Call{Call: _e.mock.On("GetPartitionStatistics",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetPartitionStatistics_Call) Run(run func(ctx context.Context, in *datapb.GetPartitionStatisticsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetPartitionStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetPartitionStatisticsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetQueryNodeDistribution provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetQueryNodeDistribution(ctx context.Context, in *querypb.GetQueryNodeDistributionRequest, opts ...grpc.CallOption) (*querypb.GetQueryNodeDistributionResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.GetQueryNodeDistributionResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetQueryNodeDistributionRequest, ...grpc.CallOption) *querypb.GetQueryNodeDistributionResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.GetQueryNodeDistributionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetQueryNodeDistributionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetQueryNodeDistribution is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.GetQueryNodeDistributionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetQueryNodeDistribution(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetQueryNodeDistribution_Call {
	return &MockMixCoordClient_GetQueryNodeDistribution_Call{Call: _e.mock.On("GetQueryNodeDistribution",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetQueryNodeDistribution_Call) Run(run func(ctx context.Context, in *querypb.GetQueryNodeDistributionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetQueryNodeDistribution_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.GetQueryNodeDistributionRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetQuotaMetrics provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetQuotaMetrics(ctx context.Context, in *internalpb.GetQuotaMetricsRequest, opts ...grpc.CallOption) (*internalpb.GetQuotaMetricsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*internalpb.GetQuotaMetricsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetQuotaMetricsRequest, ...grpc.CallOption) *internalpb.GetQuotaMetricsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.GetQuotaMetricsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetQuotaMetricsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetQuotaMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.GetQuotaMetricsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetQuotaMetrics(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetQuotaMetrics_Call {
	return &MockMixCoordClient_GetQuotaMetrics_Call{Call: _e.mock.On("GetQuotaMetrics",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetQuotaMetrics_Call) Run(run func(ctx context.Context, in *internalpb.GetQuotaMetricsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetQuotaMetrics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.GetQuotaMetricsRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetRecoveryInfo provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetRecoveryInfo(ctx context.Context, in *datapb.GetRecoveryInfoRequest, opts ...grpc.CallOption) (*datapb.GetRecoveryInfoResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetRecoveryInfoResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequest, ...grpc.CallOption) *datapb.GetRecoveryInfoResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRecoveryInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetRecoveryInfoRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetRecoveryInfo(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetRecoveryInfo_Call {
	return &MockMixCoordClient_GetRecoveryInfo_Call{Call: _e.mock.On("GetRecoveryInfo",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetRecoveryInfo_Call) Run(run func(ctx context.Context, in *datapb.GetRecoveryInfoRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetRecoveryInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetRecoveryInfoV2 provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetRecoveryInfoV2(ctx context.Context, in *datapb.GetRecoveryInfoRequestV2, opts ...grpc.CallOption) (*datapb.GetRecoveryInfoResponseV2, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetRecoveryInfoResponseV2, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequestV2, ...grpc.CallOption) *datapb.GetRecoveryInfoResponseV2); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponseV2)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequestV2, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRecoveryInfoV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetRecoveryInfoRequestV2
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetRecoveryInfoV2(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetRecoveryInfoV2_Call {
	return &MockMixCoordClient_GetRecoveryInfoV2_Call{Call: _e.mock.On("GetRecoveryInfoV2",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetRecoveryInfoV2_Call) Run(run func(ctx context.Context, in *datapb.GetRecoveryInfoRequestV2, opts ...grpc.CallOption)) *MockMixCoordClient_GetRecoveryInfoV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequestV2), variadicArgs...)
	})
	return _c
}

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

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

// GetReplicas provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetReplicas(ctx context.Context, in *milvuspb.GetReplicasRequest, opts ...grpc.CallOption) (*milvuspb.GetReplicasResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.GetReplicasResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetReplicasRequest, ...grpc.CallOption) *milvuspb.GetReplicasResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.GetReplicasResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetReplicasRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetReplicas is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.GetReplicasRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetReplicas(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetReplicas_Call {
	return &MockMixCoordClient_GetReplicas_Call{Call: _e.mock.On("GetReplicas",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetReplicas_Call) Run(run func(ctx context.Context, in *milvuspb.GetReplicasRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetReplicas_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.GetReplicasRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetSegmentIndexState provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetSegmentIndexState(ctx context.Context, in *indexpb.GetSegmentIndexStateRequest, opts ...grpc.CallOption) (*indexpb.GetSegmentIndexStateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.GetSegmentIndexStateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest, ...grpc.CallOption) *indexpb.GetSegmentIndexStateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.GetSegmentIndexStateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetSegmentIndexStateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSegmentIndexState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.GetSegmentIndexStateRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetSegmentIndexState(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetSegmentIndexState_Call {
	return &MockMixCoordClient_GetSegmentIndexState_Call{Call: _e.mock.On("GetSegmentIndexState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetSegmentIndexState_Call) Run(run func(ctx context.Context, in *indexpb.GetSegmentIndexStateRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetSegmentIndexState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.GetSegmentIndexStateRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetSegmentInfo provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetSegmentInfo(ctx context.Context, in *datapb.GetSegmentInfoRequest, opts ...grpc.CallOption) (*datapb.GetSegmentInfoResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetSegmentInfoResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoRequest, ...grpc.CallOption) *datapb.GetSegmentInfoResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetSegmentInfoResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentInfoRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSegmentInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetSegmentInfoRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetSegmentInfo(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetSegmentInfo_Call {
	return &MockMixCoordClient_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetSegmentInfo_Call) Run(run func(ctx context.Context, in *datapb.GetSegmentInfoRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetSegmentInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetSegmentInfoRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetSegmentInfoChannel provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetSegmentInfoChannel(ctx context.Context, in *datapb.GetSegmentInfoChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.StringResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoChannelRequest, ...grpc.CallOption) *milvuspb.StringResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.StringResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentInfoChannelRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSegmentInfoChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetSegmentInfoChannelRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetSegmentInfoChannel(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetSegmentInfoChannel_Call {
	return &MockMixCoordClient_GetSegmentInfoChannel_Call{Call: _e.mock.On("GetSegmentInfoChannel",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetSegmentInfoChannel_Call) Run(run func(ctx context.Context, in *datapb.GetSegmentInfoChannelRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetSegmentInfoChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetSegmentInfoChannelRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetSegmentStates provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetSegmentStates(ctx context.Context, in *datapb.GetSegmentStatesRequest, opts ...grpc.CallOption) (*datapb.GetSegmentStatesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetSegmentStatesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentStatesRequest, ...grpc.CallOption) *datapb.GetSegmentStatesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetSegmentStatesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentStatesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSegmentStates is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetSegmentStatesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetSegmentStates(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetSegmentStates_Call {
	return &MockMixCoordClient_GetSegmentStates_Call{Call: _e.mock.On("GetSegmentStates",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetSegmentStates_Call) Run(run func(ctx context.Context, in *datapb.GetSegmentStatesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetSegmentStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetSegmentStatesRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetSegmentsByStates provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetSegmentsByStates(ctx context.Context, in *datapb.GetSegmentsByStatesRequest, opts ...grpc.CallOption) (*datapb.GetSegmentsByStatesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.GetSegmentsByStatesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest, ...grpc.CallOption) *datapb.GetSegmentsByStatesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.GetSegmentsByStatesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentsByStatesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSegmentsByStates is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.GetSegmentsByStatesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetSegmentsByStates(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetSegmentsByStates_Call {
	return &MockMixCoordClient_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetSegmentsByStates_Call) Run(run func(ctx context.Context, in *datapb.GetSegmentsByStatesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetSegmentsByStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.GetSegmentsByStatesRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetShardLeaders provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetShardLeaders(ctx context.Context, in *querypb.GetShardLeadersRequest, opts ...grpc.CallOption) (*querypb.GetShardLeadersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.GetShardLeadersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetShardLeadersRequest, ...grpc.CallOption) *querypb.GetShardLeadersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.GetShardLeadersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetShardLeadersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetShardLeaders is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.GetShardLeadersRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetShardLeaders(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetShardLeaders_Call {
	return &MockMixCoordClient_GetShardLeaders_Call{Call: _e.mock.On("GetShardLeaders",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetShardLeaders_Call) Run(run func(ctx context.Context, in *querypb.GetShardLeadersRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetShardLeaders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.GetShardLeadersRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetStatisticsChannel provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.StringResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetStatisticsChannelRequest, ...grpc.CallOption) *milvuspb.StringResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.StringResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetStatisticsChannelRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetStatisticsChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.GetStatisticsChannelRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetStatisticsChannel(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetStatisticsChannel_Call {
	return &MockMixCoordClient_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetStatisticsChannel_Call) Run(run func(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetStatisticsChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.GetStatisticsChannelRequest), variadicArgs...)
	})
	return _c
}

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

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

// GetTimeTickChannel provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.StringResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetTimeTickChannelRequest, ...grpc.CallOption) *milvuspb.StringResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.StringResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetTimeTickChannelRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetTimeTickChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.GetTimeTickChannelRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) GetTimeTickChannel(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_GetTimeTickChannel_Call {
	return &MockMixCoordClient_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_GetTimeTickChannel_Call) Run(run func(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption)) *MockMixCoordClient_GetTimeTickChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.GetTimeTickChannelRequest), variadicArgs...)
	})
	return _c
}

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

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

// HasCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) HasCollection(ctx context.Context, in *milvuspb.HasCollectionRequest, opts ...grpc.CallOption) (*milvuspb.BoolResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.BoolResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.HasCollectionRequest, ...grpc.CallOption) *milvuspb.BoolResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.BoolResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.HasCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HasCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.HasCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) HasCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_HasCollection_Call {
	return &MockMixCoordClient_HasCollection_Call{Call: _e.mock.On("HasCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_HasCollection_Call) Run(run func(ctx context.Context, in *milvuspb.HasCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_HasCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.HasCollectionRequest), variadicArgs...)
	})
	return _c
}

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

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

// HasPartition provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) HasPartition(ctx context.Context, in *milvuspb.HasPartitionRequest, opts ...grpc.CallOption) (*milvuspb.BoolResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.BoolResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.HasPartitionRequest, ...grpc.CallOption) *milvuspb.BoolResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.BoolResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.HasPartitionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HasPartition is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.HasPartitionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) HasPartition(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_HasPartition_Call {
	return &MockMixCoordClient_HasPartition_Call{Call: _e.mock.On("HasPartition",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_HasPartition_Call) Run(run func(ctx context.Context, in *milvuspb.HasPartitionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_HasPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.HasPartitionRequest), variadicArgs...)
	})
	return _c
}

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

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

// ImportV2 provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ImportV2(ctx context.Context, in *internalpb.ImportRequestInternal, opts ...grpc.CallOption) (*internalpb.ImportResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*internalpb.ImportResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ImportRequestInternal, ...grpc.CallOption) *internalpb.ImportResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.ImportResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ImportRequestInternal, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ImportV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.ImportRequestInternal
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ImportV2(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ImportV2_Call {
	return &MockMixCoordClient_ImportV2_Call{Call: _e.mock.On("ImportV2",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ImportV2_Call) Run(run func(ctx context.Context, in *internalpb.ImportRequestInternal, opts ...grpc.CallOption)) *MockMixCoordClient_ImportV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.ImportRequestInternal), variadicArgs...)
	})
	return _c
}

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

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

// InvalidateCollectionMetaCache provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) InvalidateCollectionMetaCache(ctx context.Context, in *proxypb.InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InvalidateCollectionMetaCache is a helper method to define mock.On call
//   - ctx context.Context
//   - in *proxypb.InvalidateCollMetaCacheRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) InvalidateCollectionMetaCache(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_InvalidateCollectionMetaCache_Call {
	return &MockMixCoordClient_InvalidateCollectionMetaCache_Call{Call: _e.mock.On("InvalidateCollectionMetaCache",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_InvalidateCollectionMetaCache_Call) Run(run func(ctx context.Context, in *proxypb.InvalidateCollMetaCacheRequest, opts ...grpc.CallOption)) *MockMixCoordClient_InvalidateCollectionMetaCache_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*proxypb.InvalidateCollMetaCacheRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListAliases provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListAliases(ctx context.Context, in *milvuspb.ListAliasesRequest, opts ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListAliasesRequest, ...grpc.CallOption) *milvuspb.ListAliasesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListAliasesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListAliasesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAliases is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ListAliasesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListAliases(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListAliases_Call {
	return &MockMixCoordClient_ListAliases_Call{Call: _e.mock.On("ListAliases",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListAliases_Call) Run(run func(ctx context.Context, in *milvuspb.ListAliasesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListAliases_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ListAliasesRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListCheckers provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListCheckers(ctx context.Context, in *querypb.ListCheckersRequest, opts ...grpc.CallOption) (*querypb.ListCheckersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.ListCheckersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListCheckersRequest, ...grpc.CallOption) *querypb.ListCheckersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.ListCheckersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ListCheckersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListCheckers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ListCheckersRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListCheckers(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListCheckers_Call {
	return &MockMixCoordClient_ListCheckers_Call{Call: _e.mock.On("ListCheckers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListCheckers_Call) Run(run func(ctx context.Context, in *querypb.ListCheckersRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListCheckers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ListCheckersRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListCredUsers provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListCredUsers(ctx context.Context, in *milvuspb.ListCredUsersRequest, opts ...grpc.CallOption) (*milvuspb.ListCredUsersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ListCredUsersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListCredUsersRequest, ...grpc.CallOption) *milvuspb.ListCredUsersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListCredUsersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListCredUsersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListCredUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ListCredUsersRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListCredUsers(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListCredUsers_Call {
	return &MockMixCoordClient_ListCredUsers_Call{Call: _e.mock.On("ListCredUsers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListCredUsers_Call) Run(run func(ctx context.Context, in *milvuspb.ListCredUsersRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListCredUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ListCredUsersRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListDatabases provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListDatabases(ctx context.Context, in *milvuspb.ListDatabasesRequest, opts ...grpc.CallOption) (*milvuspb.ListDatabasesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ListDatabasesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListDatabasesRequest, ...grpc.CallOption) *milvuspb.ListDatabasesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListDatabasesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListDatabasesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListDatabases is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ListDatabasesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListDatabases(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListDatabases_Call {
	return &MockMixCoordClient_ListDatabases_Call{Call: _e.mock.On("ListDatabases",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListDatabases_Call) Run(run func(ctx context.Context, in *milvuspb.ListDatabasesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListDatabases_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ListDatabasesRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListFileResources provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListFileResources(ctx context.Context, in *milvuspb.ListFileResourcesRequest, opts ...grpc.CallOption) (*milvuspb.ListFileResourcesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ListFileResourcesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListFileResourcesRequest, ...grpc.CallOption) *milvuspb.ListFileResourcesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListFileResourcesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListFileResourcesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListFileResources is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ListFileResourcesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListFileResources(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListFileResources_Call {
	return &MockMixCoordClient_ListFileResources_Call{Call: _e.mock.On("ListFileResources",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListFileResources_Call) Run(run func(ctx context.Context, in *milvuspb.ListFileResourcesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListFileResources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ListFileResourcesRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListImports provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListImports(ctx context.Context, in *internalpb.ListImportsRequestInternal, opts ...grpc.CallOption) (*internalpb.ListImportsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*internalpb.ListImportsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ListImportsRequestInternal, ...grpc.CallOption) *internalpb.ListImportsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.ListImportsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ListImportsRequestInternal, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListImports is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.ListImportsRequestInternal
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListImports(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListImports_Call {
	return &MockMixCoordClient_ListImports_Call{Call: _e.mock.On("ListImports",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListImports_Call) Run(run func(ctx context.Context, in *internalpb.ListImportsRequestInternal, opts ...grpc.CallOption)) *MockMixCoordClient_ListImports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.ListImportsRequestInternal), variadicArgs...)
	})
	return _c
}

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

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

// ListIndexes provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListIndexes(ctx context.Context, in *indexpb.ListIndexesRequest, opts ...grpc.CallOption) (*indexpb.ListIndexesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*indexpb.ListIndexesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.ListIndexesRequest, ...grpc.CallOption) *indexpb.ListIndexesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*indexpb.ListIndexesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.ListIndexesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListIndexes is a helper method to define mock.On call
//   - ctx context.Context
//   - in *indexpb.ListIndexesRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListIndexes(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListIndexes_Call {
	return &MockMixCoordClient_ListIndexes_Call{Call: _e.mock.On("ListIndexes",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListIndexes_Call) Run(run func(ctx context.Context, in *indexpb.ListIndexesRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*indexpb.ListIndexesRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListLoadedSegments provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListLoadedSegments(ctx context.Context, in *querypb.ListLoadedSegmentsRequest, opts ...grpc.CallOption) (*querypb.ListLoadedSegmentsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.ListLoadedSegmentsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListLoadedSegmentsRequest, ...grpc.CallOption) *querypb.ListLoadedSegmentsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.ListLoadedSegmentsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ListLoadedSegmentsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListLoadedSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ListLoadedSegmentsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListLoadedSegments(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListLoadedSegments_Call {
	return &MockMixCoordClient_ListLoadedSegments_Call{Call: _e.mock.On("ListLoadedSegments",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListLoadedSegments_Call) Run(run func(ctx context.Context, in *querypb.ListLoadedSegmentsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListLoadedSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ListLoadedSegmentsRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListPolicy provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest, opts ...grpc.CallOption) (*internalpb.ListPolicyResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*internalpb.ListPolicyResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ListPolicyRequest, ...grpc.CallOption) *internalpb.ListPolicyResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.ListPolicyResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ListPolicyRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.ListPolicyRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListPolicy(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListPolicy_Call {
	return &MockMixCoordClient_ListPolicy_Call{Call: _e.mock.On("ListPolicy",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListPolicy_Call) Run(run func(ctx context.Context, in *internalpb.ListPolicyRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.ListPolicyRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListPrivilegeGroups provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListPrivilegeGroups(ctx context.Context, in *milvuspb.ListPrivilegeGroupsRequest, opts ...grpc.CallOption) (*milvuspb.ListPrivilegeGroupsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ListPrivilegeGroupsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListPrivilegeGroupsRequest, ...grpc.CallOption) *milvuspb.ListPrivilegeGroupsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListPrivilegeGroupsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListPrivilegeGroupsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListPrivilegeGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ListPrivilegeGroupsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListPrivilegeGroups(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListPrivilegeGroups_Call {
	return &MockMixCoordClient_ListPrivilegeGroups_Call{Call: _e.mock.On("ListPrivilegeGroups",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListPrivilegeGroups_Call) Run(run func(ctx context.Context, in *milvuspb.ListPrivilegeGroupsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListPrivilegeGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ListPrivilegeGroupsRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListQueryNode provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListQueryNode(ctx context.Context, in *querypb.ListQueryNodeRequest, opts ...grpc.CallOption) (*querypb.ListQueryNodeResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.ListQueryNodeResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListQueryNodeRequest, ...grpc.CallOption) *querypb.ListQueryNodeResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.ListQueryNodeResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ListQueryNodeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListQueryNode is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ListQueryNodeRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListQueryNode(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListQueryNode_Call {
	return &MockMixCoordClient_ListQueryNode_Call{Call: _e.mock.On("ListQueryNode",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListQueryNode_Call) Run(run func(ctx context.Context, in *querypb.ListQueryNodeRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListQueryNode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ListQueryNodeRequest), variadicArgs...)
	})
	return _c
}

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

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

// ListResourceGroups provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ListResourceGroups(ctx context.Context, in *milvuspb.ListResourceGroupsRequest, opts ...grpc.CallOption) (*milvuspb.ListResourceGroupsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ListResourceGroupsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest, ...grpc.CallOption) *milvuspb.ListResourceGroupsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListResourceGroupsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListResourceGroupsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListResourceGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ListResourceGroupsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ListResourceGroups(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ListResourceGroups_Call {
	return &MockMixCoordClient_ListResourceGroups_Call{Call: _e.mock.On("ListResourceGroups",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ListResourceGroups_Call) Run(run func(ctx context.Context, in *milvuspb.ListResourceGroupsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ListResourceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ListResourceGroupsRequest), variadicArgs...)
	})
	return _c
}

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

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

// LoadBalance provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) LoadBalance(ctx context.Context, in *querypb.LoadBalanceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadBalanceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoadBalance is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.LoadBalanceRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) LoadBalance(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_LoadBalance_Call {
	return &MockMixCoordClient_LoadBalance_Call{Call: _e.mock.On("LoadBalance",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_LoadBalance_Call) Run(run func(ctx context.Context, in *querypb.LoadBalanceRequest, opts ...grpc.CallOption)) *MockMixCoordClient_LoadBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.LoadBalanceRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_LoadBalance_Call) RunAndReturn(run func(context.Context, *querypb.LoadBalanceRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_LoadBalance_Call {
	_c.Call.Return(run)
	return _c
}

// LoadCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) LoadCollection(ctx context.Context, in *querypb.LoadCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoadCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.LoadCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) LoadCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_LoadCollection_Call {
	return &MockMixCoordClient_LoadCollection_Call{Call: _e.mock.On("LoadCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_LoadCollection_Call) Run(run func(ctx context.Context, in *querypb.LoadCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_LoadCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.LoadCollectionRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_LoadCollection_Call) RunAndReturn(run func(context.Context, *querypb.LoadCollectionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_LoadCollection_Call {
	_c.Call.Return(run)
	return _c
}

// LoadPartitions provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) LoadPartitions(ctx context.Context, in *querypb.LoadPartitionsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadPartitionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoadPartitions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.LoadPartitionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) LoadPartitions(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_LoadPartitions_Call {
	return &MockMixCoordClient_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_LoadPartitions_Call) Run(run func(ctx context.Context, in *querypb.LoadPartitionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_LoadPartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.LoadPartitionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_LoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.LoadPartitionsRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_LoadPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ManualCompaction provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ManualCompaction(ctx context.Context, in *milvuspb.ManualCompactionRequest, opts ...grpc.CallOption) (*milvuspb.ManualCompactionResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ManualCompactionResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest, ...grpc.CallOption) *milvuspb.ManualCompactionResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ManualCompactionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ManualCompactionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ManualCompaction is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ManualCompactionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ManualCompaction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ManualCompaction_Call {
	return &MockMixCoordClient_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ManualCompaction_Call) Run(run func(ctx context.Context, in *milvuspb.ManualCompactionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ManualCompaction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ManualCompactionRequest), variadicArgs...)
	})
	return _c
}

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

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

// MarkSegmentsDropped provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) MarkSegmentsDropped(ctx context.Context, in *datapb.MarkSegmentsDroppedRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.MarkSegmentsDroppedRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// MarkSegmentsDropped is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.MarkSegmentsDroppedRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) MarkSegmentsDropped(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_MarkSegmentsDropped_Call {
	return &MockMixCoordClient_MarkSegmentsDropped_Call{Call: _e.mock.On("MarkSegmentsDropped",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_MarkSegmentsDropped_Call) Run(run func(ctx context.Context, in *datapb.MarkSegmentsDroppedRequest, opts ...grpc.CallOption)) *MockMixCoordClient_MarkSegmentsDropped_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.MarkSegmentsDroppedRequest), variadicArgs...)
	})
	return _c
}

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

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

// OperatePrivilege provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) OperatePrivilege(ctx context.Context, in *milvuspb.OperatePrivilegeRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperatePrivilegeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OperatePrivilege is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.OperatePrivilegeRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) OperatePrivilege(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_OperatePrivilege_Call {
	return &MockMixCoordClient_OperatePrivilege_Call{Call: _e.mock.On("OperatePrivilege",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_OperatePrivilege_Call) Run(run func(ctx context.Context, in *milvuspb.OperatePrivilegeRequest, opts ...grpc.CallOption)) *MockMixCoordClient_OperatePrivilege_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.OperatePrivilegeRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_OperatePrivilege_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_OperatePrivilege_Call {
	_c.Call.Return(run)
	return _c
}

// OperatePrivilegeGroup provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) OperatePrivilegeGroup(ctx context.Context, in *milvuspb.OperatePrivilegeGroupRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OperatePrivilegeGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.OperatePrivilegeGroupRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) OperatePrivilegeGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_OperatePrivilegeGroup_Call {
	return &MockMixCoordClient_OperatePrivilegeGroup_Call{Call: _e.mock.On("OperatePrivilegeGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_OperatePrivilegeGroup_Call) Run(run func(ctx context.Context, in *milvuspb.OperatePrivilegeGroupRequest, opts ...grpc.CallOption)) *MockMixCoordClient_OperatePrivilegeGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.OperatePrivilegeGroupRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_OperatePrivilegeGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeGroupRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_OperatePrivilegeGroup_Call {
	_c.Call.Return(run)
	return _c
}

// OperateUserRole provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) OperateUserRole(ctx context.Context, in *milvuspb.OperateUserRoleRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperateUserRoleRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OperateUserRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.OperateUserRoleRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) OperateUserRole(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_OperateUserRole_Call {
	return &MockMixCoordClient_OperateUserRole_Call{Call: _e.mock.On("OperateUserRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_OperateUserRole_Call) Run(run func(ctx context.Context, in *milvuspb.OperateUserRoleRequest, opts ...grpc.CallOption)) *MockMixCoordClient_OperateUserRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.OperateUserRoleRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_OperateUserRole_Call) RunAndReturn(run func(context.Context, *milvuspb.OperateUserRoleRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_OperateUserRole_Call {
	_c.Call.Return(run)
	return _c
}

// ReleaseCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ReleaseCollection(ctx context.Context, in *querypb.ReleaseCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleaseCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ReleaseCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ReleaseCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ReleaseCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ReleaseCollection_Call {
	return &MockMixCoordClient_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ReleaseCollection_Call) Run(run func(ctx context.Context, in *querypb.ReleaseCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ReleaseCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ReleaseCollectionRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ReleaseCollection_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseCollectionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_ReleaseCollection_Call {
	_c.Call.Return(run)
	return _c
}

// ReleasePartitions provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ReleasePartitions(ctx context.Context, in *querypb.ReleasePartitionsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleasePartitionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ReleasePartitions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ReleasePartitionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ReleasePartitions(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ReleasePartitions_Call {
	return &MockMixCoordClient_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ReleasePartitions_Call) Run(run func(ctx context.Context, in *querypb.ReleasePartitionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ReleasePartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ReleasePartitionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ReleasePartitions_Call) RunAndReturn(run func(context.Context, *querypb.ReleasePartitionsRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_ReleasePartitions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveFileResource provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) RemoveFileResource(ctx context.Context, in *milvuspb.RemoveFileResourceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RemoveFileResourceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RemoveFileResource is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.RemoveFileResourceRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) RemoveFileResource(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_RemoveFileResource_Call {
	return &MockMixCoordClient_RemoveFileResource_Call{Call: _e.mock.On("RemoveFileResource",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_RemoveFileResource_Call) Run(run func(ctx context.Context, in *milvuspb.RemoveFileResourceRequest, opts ...grpc.CallOption)) *MockMixCoordClient_RemoveFileResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.RemoveFileResourceRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_RemoveFileResource_Call) RunAndReturn(run func(context.Context, *milvuspb.RemoveFileResourceRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_RemoveFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// RenameCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) RenameCollection(ctx context.Context, in *milvuspb.RenameCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RenameCollectionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RenameCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.RenameCollectionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) RenameCollection(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_RenameCollection_Call {
	return &MockMixCoordClient_RenameCollection_Call{Call: _e.mock.On("RenameCollection",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_RenameCollection_Call) Run(run func(ctx context.Context, in *milvuspb.RenameCollectionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_RenameCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.RenameCollectionRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_RenameCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.RenameCollectionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_RenameCollection_Call {
	_c.Call.Return(run)
	return _c
}

// ReportDataNodeTtMsgs provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ReportDataNodeTtMsgs(ctx context.Context, in *datapb.ReportDataNodeTtMsgsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ReportDataNodeTtMsgs is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.ReportDataNodeTtMsgsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ReportDataNodeTtMsgs(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ReportDataNodeTtMsgs_Call {
	return &MockMixCoordClient_ReportDataNodeTtMsgs_Call{Call: _e.mock.On("ReportDataNodeTtMsgs",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ReportDataNodeTtMsgs_Call) Run(run func(ctx context.Context, in *datapb.ReportDataNodeTtMsgsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ReportDataNodeTtMsgs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.ReportDataNodeTtMsgsRequest), variadicArgs...)
	})
	return _c
}

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

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

// RestoreRBAC provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) RestoreRBAC(ctx context.Context, in *milvuspb.RestoreRBACMetaRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreRBACMetaRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RestoreRBACMetaRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RestoreRBAC is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.RestoreRBACMetaRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) RestoreRBAC(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_RestoreRBAC_Call {
	return &MockMixCoordClient_RestoreRBAC_Call{Call: _e.mock.On("RestoreRBAC",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_RestoreRBAC_Call) Run(run func(ctx context.Context, in *milvuspb.RestoreRBACMetaRequest, opts ...grpc.CallOption)) *MockMixCoordClient_RestoreRBAC_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.RestoreRBACMetaRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_RestoreRBAC_Call) RunAndReturn(run func(context.Context, *milvuspb.RestoreRBACMetaRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_RestoreRBAC_Call {
	_c.Call.Return(run)
	return _c
}

// ResumeBalance provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ResumeBalance(ctx context.Context, in *querypb.ResumeBalanceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeBalanceRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ResumeBalanceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ResumeBalance is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ResumeBalanceRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ResumeBalance(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ResumeBalance_Call {
	return &MockMixCoordClient_ResumeBalance_Call{Call: _e.mock.On("ResumeBalance",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ResumeBalance_Call) Run(run func(ctx context.Context, in *querypb.ResumeBalanceRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ResumeBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ResumeBalanceRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ResumeBalance_Call) RunAndReturn(run func(context.Context, *querypb.ResumeBalanceRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_ResumeBalance_Call {
	_c.Call.Return(run)
	return _c
}

// ResumeNode provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ResumeNode(ctx context.Context, in *querypb.ResumeNodeRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeNodeRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ResumeNodeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ResumeNode is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ResumeNodeRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ResumeNode(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ResumeNode_Call {
	return &MockMixCoordClient_ResumeNode_Call{Call: _e.mock.On("ResumeNode",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ResumeNode_Call) Run(run func(ctx context.Context, in *querypb.ResumeNodeRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ResumeNode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ResumeNodeRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ResumeNode_Call) RunAndReturn(run func(context.Context, *querypb.ResumeNodeRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_ResumeNode_Call {
	_c.Call.Return(run)
	return _c
}

// SaveBinlogPaths provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SaveBinlogPaths(ctx context.Context, in *datapb.SaveBinlogPathsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.SaveBinlogPathsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SaveBinlogPaths is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.SaveBinlogPathsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SaveBinlogPaths(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SaveBinlogPaths_Call {
	return &MockMixCoordClient_SaveBinlogPaths_Call{Call: _e.mock.On("SaveBinlogPaths",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SaveBinlogPaths_Call) Run(run func(ctx context.Context, in *datapb.SaveBinlogPathsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SaveBinlogPaths_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.SaveBinlogPathsRequest), variadicArgs...)
	})
	return _c
}

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

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

// SelectGrant provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SelectGrant(ctx context.Context, in *milvuspb.SelectGrantRequest, opts ...grpc.CallOption) (*milvuspb.SelectGrantResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.SelectGrantResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectGrantRequest, ...grpc.CallOption) *milvuspb.SelectGrantResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SelectGrantResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectGrantRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectGrant is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.SelectGrantRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SelectGrant(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SelectGrant_Call {
	return &MockMixCoordClient_SelectGrant_Call{Call: _e.mock.On("SelectGrant",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SelectGrant_Call) Run(run func(ctx context.Context, in *milvuspb.SelectGrantRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SelectGrant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.SelectGrantRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_SelectGrant_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectGrantRequest, ...grpc.CallOption) (*milvuspb.SelectGrantResponse, error)) *MockMixCoordClient_SelectGrant_Call {
	_c.Call.Return(run)
	return _c
}

// SelectRole provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SelectRole(ctx context.Context, in *milvuspb.SelectRoleRequest, opts ...grpc.CallOption) (*milvuspb.SelectRoleResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.SelectRoleResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectRoleRequest, ...grpc.CallOption) *milvuspb.SelectRoleResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SelectRoleResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectRoleRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.SelectRoleRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SelectRole(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SelectRole_Call {
	return &MockMixCoordClient_SelectRole_Call{Call: _e.mock.On("SelectRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SelectRole_Call) Run(run func(ctx context.Context, in *milvuspb.SelectRoleRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SelectRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.SelectRoleRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_SelectRole_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectRoleRequest, ...grpc.CallOption) (*milvuspb.SelectRoleResponse, error)) *MockMixCoordClient_SelectRole_Call {
	_c.Call.Return(run)
	return _c
}

// SelectUser provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SelectUser(ctx context.Context, in *milvuspb.SelectUserRequest, opts ...grpc.CallOption) (*milvuspb.SelectUserResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.SelectUserResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectUserRequest, ...grpc.CallOption) *milvuspb.SelectUserResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SelectUserResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectUserRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectUser is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.SelectUserRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SelectUser(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SelectUser_Call {
	return &MockMixCoordClient_SelectUser_Call{Call: _e.mock.On("SelectUser",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SelectUser_Call) Run(run func(ctx context.Context, in *milvuspb.SelectUserRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SelectUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.SelectUserRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_SelectUser_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectUserRequest, ...grpc.CallOption) (*milvuspb.SelectUserResponse, error)) *MockMixCoordClient_SelectUser_Call {
	_c.Call.Return(run)
	return _c
}

// SetSegmentState provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SetSegmentState(ctx context.Context, in *datapb.SetSegmentStateRequest, opts ...grpc.CallOption) (*datapb.SetSegmentStateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.SetSegmentStateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SetSegmentStateRequest, ...grpc.CallOption) *datapb.SetSegmentStateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.SetSegmentStateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.SetSegmentStateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetSegmentState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.SetSegmentStateRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SetSegmentState(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SetSegmentState_Call {
	return &MockMixCoordClient_SetSegmentState_Call{Call: _e.mock.On("SetSegmentState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SetSegmentState_Call) Run(run func(ctx context.Context, in *datapb.SetSegmentStateRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SetSegmentState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.SetSegmentStateRequest), variadicArgs...)
	})
	return _c
}

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

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

// ShowCollectionIDs provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowCollectionIDs(ctx context.Context, in *rootcoordpb.ShowCollectionIDsRequest, opts ...grpc.CallOption) (*rootcoordpb.ShowCollectionIDsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*rootcoordpb.ShowCollectionIDsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.ShowCollectionIDsRequest, ...grpc.CallOption) *rootcoordpb.ShowCollectionIDsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rootcoordpb.ShowCollectionIDsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.ShowCollectionIDsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowCollectionIDs is a helper method to define mock.On call
//   - ctx context.Context
//   - in *rootcoordpb.ShowCollectionIDsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowCollectionIDs(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowCollectionIDs_Call {
	return &MockMixCoordClient_ShowCollectionIDs_Call{Call: _e.mock.On("ShowCollectionIDs",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowCollectionIDs_Call) Run(run func(ctx context.Context, in *rootcoordpb.ShowCollectionIDsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowCollectionIDs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*rootcoordpb.ShowCollectionIDsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowCollectionIDs_Call) RunAndReturn(run func(context.Context, *rootcoordpb.ShowCollectionIDsRequest, ...grpc.CallOption) (*rootcoordpb.ShowCollectionIDsResponse, error)) *MockMixCoordClient_ShowCollectionIDs_Call {
	_c.Call.Return(run)
	return _c
}

// ShowCollections provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowCollectionsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ShowCollectionsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowCollectionsRequest, ...grpc.CallOption) *milvuspb.ShowCollectionsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ShowCollectionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowCollectionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowCollections is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ShowCollectionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowCollections(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowCollections_Call {
	return &MockMixCoordClient_ShowCollections_Call{Call: _e.mock.On("ShowCollections",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowCollections_Call) Run(run func(ctx context.Context, in *milvuspb.ShowCollectionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowCollections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ShowCollectionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowCollections_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowCollectionsRequest, ...grpc.CallOption) (*milvuspb.ShowCollectionsResponse, error)) *MockMixCoordClient_ShowCollections_Call {
	_c.Call.Return(run)
	return _c
}

// ShowConfigurations provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowConfigurations(ctx context.Context, in *internalpb.ShowConfigurationsRequest, opts ...grpc.CallOption) (*internalpb.ShowConfigurationsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*internalpb.ShowConfigurationsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest, ...grpc.CallOption) *internalpb.ShowConfigurationsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.ShowConfigurationsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ShowConfigurationsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.ShowConfigurationsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowConfigurations(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowConfigurations_Call {
	return &MockMixCoordClient_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowConfigurations_Call) Run(run func(ctx context.Context, in *internalpb.ShowConfigurationsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.ShowConfigurationsRequest), variadicArgs...)
	})
	return _c
}

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

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

// ShowLoadCollections provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowLoadCollections(ctx context.Context, in *querypb.ShowCollectionsRequest, opts ...grpc.CallOption) (*querypb.ShowCollectionsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.ShowCollectionsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ShowCollectionsRequest, ...grpc.CallOption) *querypb.ShowCollectionsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.ShowCollectionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ShowCollectionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowLoadCollections is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ShowCollectionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowLoadCollections(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowLoadCollections_Call {
	return &MockMixCoordClient_ShowLoadCollections_Call{Call: _e.mock.On("ShowLoadCollections",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowLoadCollections_Call) Run(run func(ctx context.Context, in *querypb.ShowCollectionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowLoadCollections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ShowCollectionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowLoadCollections_Call) RunAndReturn(run func(context.Context, *querypb.ShowCollectionsRequest, ...grpc.CallOption) (*querypb.ShowCollectionsResponse, error)) *MockMixCoordClient_ShowLoadCollections_Call {
	_c.Call.Return(run)
	return _c
}

// ShowLoadPartitions provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowLoadPartitions(ctx context.Context, in *querypb.ShowPartitionsRequest, opts ...grpc.CallOption) (*querypb.ShowPartitionsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*querypb.ShowPartitionsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ShowPartitionsRequest, ...grpc.CallOption) *querypb.ShowPartitionsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*querypb.ShowPartitionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.ShowPartitionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowLoadPartitions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.ShowPartitionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowLoadPartitions(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowLoadPartitions_Call {
	return &MockMixCoordClient_ShowLoadPartitions_Call{Call: _e.mock.On("ShowLoadPartitions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowLoadPartitions_Call) Run(run func(ctx context.Context, in *querypb.ShowPartitionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowLoadPartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.ShowPartitionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowLoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.ShowPartitionsRequest, ...grpc.CallOption) (*querypb.ShowPartitionsResponse, error)) *MockMixCoordClient_ShowLoadPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPartitions provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowPartitions(ctx context.Context, in *milvuspb.ShowPartitionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest, ...grpc.CallOption) *milvuspb.ShowPartitionsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ShowPartitionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowPartitionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowPartitions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ShowPartitionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowPartitions(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowPartitions_Call {
	return &MockMixCoordClient_ShowPartitions_Call{Call: _e.mock.On("ShowPartitions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowPartitions_Call) Run(run func(ctx context.Context, in *milvuspb.ShowPartitionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowPartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ShowPartitionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowPartitions_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowPartitionsRequest, ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error)) *MockMixCoordClient_ShowPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPartitionsInternal provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowPartitionsInternal(ctx context.Context, in *milvuspb.ShowPartitionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest, ...grpc.CallOption) *milvuspb.ShowPartitionsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ShowPartitionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowPartitionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowPartitionsInternal is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ShowPartitionsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowPartitionsInternal(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowPartitionsInternal_Call {
	return &MockMixCoordClient_ShowPartitionsInternal_Call{Call: _e.mock.On("ShowPartitionsInternal",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowPartitionsInternal_Call) Run(run func(ctx context.Context, in *milvuspb.ShowPartitionsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowPartitionsInternal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ShowPartitionsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowPartitionsInternal_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowPartitionsRequest, ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error)) *MockMixCoordClient_ShowPartitionsInternal_Call {
	_c.Call.Return(run)
	return _c
}

// ShowSegments provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequest, opts ...grpc.CallOption) (*milvuspb.ShowSegmentsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*milvuspb.ShowSegmentsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowSegmentsRequest, ...grpc.CallOption) *milvuspb.ShowSegmentsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ShowSegmentsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowSegmentsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.ShowSegmentsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) ShowSegments(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_ShowSegments_Call {
	return &MockMixCoordClient_ShowSegments_Call{Call: _e.mock.On("ShowSegments",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_ShowSegments_Call) Run(run func(ctx context.Context, in *milvuspb.ShowSegmentsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_ShowSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.ShowSegmentsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_ShowSegments_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowSegmentsRequest, ...grpc.CallOption) (*milvuspb.ShowSegmentsResponse, error)) *MockMixCoordClient_ShowSegments_Call {
	_c.Call.Return(run)
	return _c
}

// SuspendBalance provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SuspendBalance(ctx context.Context, in *querypb.SuspendBalanceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendBalanceRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.SuspendBalanceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SuspendBalance is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.SuspendBalanceRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SuspendBalance(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SuspendBalance_Call {
	return &MockMixCoordClient_SuspendBalance_Call{Call: _e.mock.On("SuspendBalance",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SuspendBalance_Call) Run(run func(ctx context.Context, in *querypb.SuspendBalanceRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SuspendBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.SuspendBalanceRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_SuspendBalance_Call) RunAndReturn(run func(context.Context, *querypb.SuspendBalanceRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_SuspendBalance_Call {
	_c.Call.Return(run)
	return _c
}

// SuspendNode provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SuspendNode(ctx context.Context, in *querypb.SuspendNodeRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendNodeRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.SuspendNodeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SuspendNode is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.SuspendNodeRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SuspendNode(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SuspendNode_Call {
	return &MockMixCoordClient_SuspendNode_Call{Call: _e.mock.On("SuspendNode",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SuspendNode_Call) Run(run func(ctx context.Context, in *querypb.SuspendNodeRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SuspendNode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.SuspendNodeRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_SuspendNode_Call) RunAndReturn(run func(context.Context, *querypb.SuspendNodeRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_SuspendNode_Call {
	_c.Call.Return(run)
	return _c
}

// SyncNewCreatedPartition provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) SyncNewCreatedPartition(ctx context.Context, in *querypb.SyncNewCreatedPartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SyncNewCreatedPartition is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.SyncNewCreatedPartitionRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) SyncNewCreatedPartition(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_SyncNewCreatedPartition_Call {
	return &MockMixCoordClient_SyncNewCreatedPartition_Call{Call: _e.mock.On("SyncNewCreatedPartition",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_SyncNewCreatedPartition_Call) Run(run func(ctx context.Context, in *querypb.SyncNewCreatedPartitionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_SyncNewCreatedPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.SyncNewCreatedPartitionRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_SyncNewCreatedPartition_Call) RunAndReturn(run func(context.Context, *querypb.SyncNewCreatedPartitionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_SyncNewCreatedPartition_Call {
	_c.Call.Return(run)
	return _c
}

// TransferChannel provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) TransferChannel(ctx context.Context, in *querypb.TransferChannelRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferChannelRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.TransferChannelRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.TransferChannelRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) TransferChannel(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_TransferChannel_Call {
	return &MockMixCoordClient_TransferChannel_Call{Call: _e.mock.On("TransferChannel",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_TransferChannel_Call) Run(run func(ctx context.Context, in *querypb.TransferChannelRequest, opts ...grpc.CallOption)) *MockMixCoordClient_TransferChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.TransferChannelRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_TransferChannel_Call) RunAndReturn(run func(context.Context, *querypb.TransferChannelRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_TransferChannel_Call {
	_c.Call.Return(run)
	return _c
}

// TransferNode provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) TransferNode(ctx context.Context, in *milvuspb.TransferNodeRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.TransferNodeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferNode is a helper method to define mock.On call
//   - ctx context.Context
//   - in *milvuspb.TransferNodeRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) TransferNode(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_TransferNode_Call {
	return &MockMixCoordClient_TransferNode_Call{Call: _e.mock.On("TransferNode",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_TransferNode_Call) Run(run func(ctx context.Context, in *milvuspb.TransferNodeRequest, opts ...grpc.CallOption)) *MockMixCoordClient_TransferNode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*milvuspb.TransferNodeRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_TransferNode_Call) RunAndReturn(run func(context.Context, *milvuspb.TransferNodeRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_TransferNode_Call {
	_c.Call.Return(run)
	return _c
}

// TransferReplica provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) TransferReplica(ctx context.Context, in *querypb.TransferReplicaRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.TransferReplicaRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferReplica is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.TransferReplicaRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) TransferReplica(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_TransferReplica_Call {
	return &MockMixCoordClient_TransferReplica_Call{Call: _e.mock.On("TransferReplica",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_TransferReplica_Call) Run(run func(ctx context.Context, in *querypb.TransferReplicaRequest, opts ...grpc.CallOption)) *MockMixCoordClient_TransferReplica_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.TransferReplicaRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_TransferReplica_Call) RunAndReturn(run func(context.Context, *querypb.TransferReplicaRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_TransferReplica_Call {
	_c.Call.Return(run)
	return _c
}

// TransferSegment provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) TransferSegment(ctx context.Context, in *querypb.TransferSegmentRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferSegmentRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.TransferSegmentRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TransferSegment is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.TransferSegmentRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) TransferSegment(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_TransferSegment_Call {
	return &MockMixCoordClient_TransferSegment_Call{Call: _e.mock.On("TransferSegment",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_TransferSegment_Call) Run(run func(ctx context.Context, in *querypb.TransferSegmentRequest, opts ...grpc.CallOption)) *MockMixCoordClient_TransferSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.TransferSegmentRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_TransferSegment_Call) RunAndReturn(run func(context.Context, *querypb.TransferSegmentRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_TransferSegment_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannelCheckpoint provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) UpdateChannelCheckpoint(ctx context.Context, in *datapb.UpdateChannelCheckpointRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateChannelCheckpointRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateChannelCheckpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.UpdateChannelCheckpointRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) UpdateChannelCheckpoint(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_UpdateChannelCheckpoint_Call {
	return &MockMixCoordClient_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_UpdateChannelCheckpoint_Call) Run(run func(ctx context.Context, in *datapb.UpdateChannelCheckpointRequest, opts ...grpc.CallOption)) *MockMixCoordClient_UpdateChannelCheckpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.UpdateChannelCheckpointRequest), variadicArgs...)
	})
	return _c
}

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

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

// UpdateChannelTimeTick provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) UpdateChannelTimeTick(ctx context.Context, in *internalpb.ChannelTimeTickMsg, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ChannelTimeTickMsg, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ChannelTimeTickMsg, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateChannelTimeTick is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.ChannelTimeTickMsg
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) UpdateChannelTimeTick(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_UpdateChannelTimeTick_Call {
	return &MockMixCoordClient_UpdateChannelTimeTick_Call{Call: _e.mock.On("UpdateChannelTimeTick",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_UpdateChannelTimeTick_Call) Run(run func(ctx context.Context, in *internalpb.ChannelTimeTickMsg, opts ...grpc.CallOption)) *MockMixCoordClient_UpdateChannelTimeTick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.ChannelTimeTickMsg), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_UpdateChannelTimeTick_Call) RunAndReturn(run func(context.Context, *internalpb.ChannelTimeTickMsg, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_UpdateChannelTimeTick_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateCredential provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) UpdateCredential(ctx context.Context, in *internalpb.CredentialInfo, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *internalpb.CredentialInfo, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - in *internalpb.CredentialInfo
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) UpdateCredential(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_UpdateCredential_Call {
	return &MockMixCoordClient_UpdateCredential_Call{Call: _e.mock.On("UpdateCredential",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_UpdateCredential_Call) Run(run func(ctx context.Context, in *internalpb.CredentialInfo, opts ...grpc.CallOption)) *MockMixCoordClient_UpdateCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*internalpb.CredentialInfo), variadicArgs...)
	})
	return _c
}

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

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

// UpdateLoadConfig provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) UpdateLoadConfig(ctx context.Context, in *querypb.UpdateLoadConfigRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateLoadConfigRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.UpdateLoadConfigRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateLoadConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.UpdateLoadConfigRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) UpdateLoadConfig(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_UpdateLoadConfig_Call {
	return &MockMixCoordClient_UpdateLoadConfig_Call{Call: _e.mock.On("UpdateLoadConfig",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_UpdateLoadConfig_Call) Run(run func(ctx context.Context, in *querypb.UpdateLoadConfigRequest, opts ...grpc.CallOption)) *MockMixCoordClient_UpdateLoadConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.UpdateLoadConfigRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_UpdateLoadConfig_Call) RunAndReturn(run func(context.Context, *querypb.UpdateLoadConfigRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_UpdateLoadConfig_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateResourceGroups provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) UpdateResourceGroups(ctx context.Context, in *querypb.UpdateResourceGroupsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateResourceGroupsRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *querypb.UpdateResourceGroupsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateResourceGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - in *querypb.UpdateResourceGroupsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) UpdateResourceGroups(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_UpdateResourceGroups_Call {
	return &MockMixCoordClient_UpdateResourceGroups_Call{Call: _e.mock.On("UpdateResourceGroups",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_UpdateResourceGroups_Call) Run(run func(ctx context.Context, in *querypb.UpdateResourceGroupsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_UpdateResourceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*querypb.UpdateResourceGroupsRequest), variadicArgs...)
	})
	return _c
}

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

func (_c *MockMixCoordClient_UpdateResourceGroups_Call) RunAndReturn(run func(context.Context, *querypb.UpdateResourceGroupsRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_UpdateResourceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSegmentStatistics provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) UpdateSegmentStatistics(ctx context.Context, in *datapb.UpdateSegmentStatisticsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*commonpb.Status, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest, ...grpc.CallOption) *commonpb.Status); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateSegmentStatistics is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.UpdateSegmentStatisticsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) UpdateSegmentStatistics(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_UpdateSegmentStatistics_Call {
	return &MockMixCoordClient_UpdateSegmentStatistics_Call{Call: _e.mock.On("UpdateSegmentStatistics",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_UpdateSegmentStatistics_Call) Run(run func(ctx context.Context, in *datapb.UpdateSegmentStatisticsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_UpdateSegmentStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.UpdateSegmentStatisticsRequest), variadicArgs...)
	})
	return _c
}

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

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

// WatchChannels provides a mock function with given fields: ctx, in, opts
func (_m *MockMixCoordClient) WatchChannels(ctx context.Context, in *datapb.WatchChannelsRequest, opts ...grpc.CallOption) (*datapb.WatchChannelsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	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, ...grpc.CallOption) (*datapb.WatchChannelsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.WatchChannelsRequest, ...grpc.CallOption) *datapb.WatchChannelsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*datapb.WatchChannelsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *datapb.WatchChannelsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WatchChannels is a helper method to define mock.On call
//   - ctx context.Context
//   - in *datapb.WatchChannelsRequest
//   - opts ...grpc.CallOption
func (_e *MockMixCoordClient_Expecter) WatchChannels(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_WatchChannels_Call {
	return &MockMixCoordClient_WatchChannels_Call{Call: _e.mock.On("WatchChannels",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockMixCoordClient_WatchChannels_Call) Run(run func(ctx context.Context, in *datapb.WatchChannelsRequest, opts ...grpc.CallOption)) *MockMixCoordClient_WatchChannels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*datapb.WatchChannelsRequest), variadicArgs...)
	})
	return _c
}

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

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

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

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

	return mock
}