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

package milvusclient

import (
	context "context"

	commonpb "github.com/milvus-io/milvus-proto/go-api/v3/commonpb"
	federpb "github.com/milvus-io/milvus-proto/go-api/v3/federpb"
	milvuspb "github.com/milvus-io/milvus-proto/go-api/v3/milvuspb"
	mock "github.com/stretchr/testify/mock"
)

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

type MilvusServiceServer_Expecter struct {
	mock *mock.Mock
}

func (_m *MilvusServiceServer) EXPECT() *MilvusServiceServer_Expecter {
	return &MilvusServiceServer_Expecter{mock: &_m.Mock}
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// AddCollectionStructField is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AddCollectionStructFieldRequest
func (_e *MilvusServiceServer_Expecter) AddCollectionStructField(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_AddCollectionStructField_Call {
	return &MilvusServiceServer_AddCollectionStructField_Call{Call: _e.mock.On("AddCollectionStructField", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// AddUserTags is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AddUserTagsRequest
func (_e *MilvusServiceServer_Expecter) AddUserTags(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_AddUserTags_Call {
	return &MilvusServiceServer_AddUserTags_Call{Call: _e.mock.On("AddUserTags", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// AlterCollectionSchema provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) AlterCollectionSchema(_a0 context.Context, _a1 *milvuspb.AlterCollectionSchemaRequest) (*milvuspb.AlterCollectionSchemaResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// AlterCollectionSchema is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AlterCollectionSchemaRequest
func (_e *MilvusServiceServer_Expecter) AlterCollectionSchema(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_AlterCollectionSchema_Call {
	return &MilvusServiceServer_AlterCollectionSchema_Call{Call: _e.mock.On("AlterCollectionSchema", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_AlterCollectionSchema_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionSchemaRequest) (*milvuspb.AlterCollectionSchemaResponse, error)) *MilvusServiceServer_AlterCollectionSchema_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// AlterRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.AlterRoleRequest
func (_e *MilvusServiceServer_Expecter) AlterRole(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_AlterRole_Call {
	return &MilvusServiceServer_AlterRole_Call{Call: _e.mock.On("AlterRole", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// BatchDescribeCollection provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) BatchDescribeCollection(_a0 context.Context, _a1 *milvuspb.BatchDescribeCollectionRequest) (*milvuspb.BatchDescribeCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// BatchDescribeCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.BatchDescribeCollectionRequest
func (_e *MilvusServiceServer_Expecter) BatchDescribeCollection(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_BatchDescribeCollection_Call {
	return &MilvusServiceServer_BatchDescribeCollection_Call{Call: _e.mock.On("BatchDescribeCollection", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_BatchDescribeCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.BatchDescribeCollectionRequest) (*milvuspb.BatchDescribeCollectionResponse, error)) *MilvusServiceServer_BatchDescribeCollection_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// CalcDistance provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) CalcDistance(_a0 context.Context, _a1 *milvuspb.CalcDistanceRequest) (*milvuspb.CalcDistanceResults, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// CalcDistance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CalcDistanceRequest
func (_e *MilvusServiceServer_Expecter) CalcDistance(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_CalcDistance_Call {
	return &MilvusServiceServer_CalcDistance_Call{Call: _e.mock.On("CalcDistance", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_CalcDistance_Call) RunAndReturn(run func(context.Context, *milvuspb.CalcDistanceRequest) (*milvuspb.CalcDistanceResults, error)) *MilvusServiceServer_CalcDistance_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// ComputePhraseMatchSlop provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ComputePhraseMatchSlop(_a0 context.Context, _a1 *milvuspb.ComputePhraseMatchSlopRequest) (*milvuspb.ComputePhraseMatchSlopResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ComputePhraseMatchSlop is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ComputePhraseMatchSlopRequest
func (_e *MilvusServiceServer_Expecter) ComputePhraseMatchSlop(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ComputePhraseMatchSlop_Call {
	return &MilvusServiceServer_ComputePhraseMatchSlop_Call{Call: _e.mock.On("ComputePhraseMatchSlop", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_ComputePhraseMatchSlop_Call) RunAndReturn(run func(context.Context, *milvuspb.ComputePhraseMatchSlopRequest) (*milvuspb.ComputePhraseMatchSlopResponse, error)) *MilvusServiceServer_ComputePhraseMatchSlop_Call {
	_c.Call.Return(run)
	return _c
}

// Connect provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Connect(_a0 context.Context, _a1 *milvuspb.ConnectRequest) (*milvuspb.ConnectResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// Connect is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ConnectRequest
func (_e *MilvusServiceServer_Expecter) Connect(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Connect_Call {
	return &MilvusServiceServer_Connect_Call{Call: _e.mock.On("Connect", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_Connect_Call) RunAndReturn(run func(context.Context, *milvuspb.ConnectRequest) (*milvuspb.ConnectResponse, error)) *MilvusServiceServer_Connect_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// CreateCredential is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateCredentialRequest
func (_e *MilvusServiceServer_Expecter) CreateCredential(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_CreateCredential_Call {
	return &MilvusServiceServer_CreateCredential_Call{Call: _e.mock.On("CreateCredential", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// CreateNamespace provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) CreateNamespace(_a0 context.Context, _a1 *milvuspb.CreateNamespaceRequest) (*milvuspb.CreateNamespaceResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// CreateNamespace is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateNamespaceRequest
func (_e *MilvusServiceServer_Expecter) CreateNamespace(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_CreateNamespace_Call {
	return &MilvusServiceServer_CreateNamespace_Call{Call: _e.mock.On("CreateNamespace", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_CreateNamespace_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateNamespaceRequest) (*milvuspb.CreateNamespaceResponse, error)) *MilvusServiceServer_CreateNamespace_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// CreateReplicateStream provides a mock function with given fields: _a0
func (_m *MilvusServiceServer) CreateReplicateStream(_a0 milvuspb.MilvusService_CreateReplicateStreamServer) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// CreateReplicateStream is a helper method to define mock.On call
//   - _a0 milvuspb.MilvusService_CreateReplicateStreamServer
func (_e *MilvusServiceServer_Expecter) CreateReplicateStream(_a0 interface{}) *MilvusServiceServer_CreateReplicateStream_Call {
	return &MilvusServiceServer_CreateReplicateStream_Call{Call: _e.mock.On("CreateReplicateStream", _a0)}
}

func (_c *MilvusServiceServer_CreateReplicateStream_Call) Run(run func(_a0 milvuspb.MilvusService_CreateReplicateStreamServer)) *MilvusServiceServer_CreateReplicateStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(milvuspb.MilvusService_CreateReplicateStreamServer))
	})
	return _c
}

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

func (_c *MilvusServiceServer_CreateReplicateStream_Call) RunAndReturn(run func(milvuspb.MilvusService_CreateReplicateStreamServer) error) *MilvusServiceServer_CreateReplicateStream_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// CreateRowPolicy is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.CreateRowPolicyRequest
func (_e *MilvusServiceServer_Expecter) CreateRowPolicy(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_CreateRowPolicy_Call {
	return &MilvusServiceServer_CreateRowPolicy_Call{Call: _e.mock.On("CreateRowPolicy", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// Delete provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Delete(_a0 context.Context, _a1 *milvuspb.DeleteRequest) (*milvuspb.MutationResult, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// Delete is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DeleteRequest
func (_e *MilvusServiceServer_Expecter) Delete(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Delete_Call {
	return &MilvusServiceServer_Delete_Call{Call: _e.mock.On("Delete", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_Delete_Call) RunAndReturn(run func(context.Context, *milvuspb.DeleteRequest) (*milvuspb.MutationResult, error)) *MilvusServiceServer_Delete_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// DeleteUserTags is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DeleteUserTagsRequest
func (_e *MilvusServiceServer_Expecter) DeleteUserTags(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DeleteUserTags_Call {
	return &MilvusServiceServer_DeleteUserTags_Call{Call: _e.mock.On("DeleteUserTags", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// DescribeNamespace provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) DescribeNamespace(_a0 context.Context, _a1 *milvuspb.DescribeNamespaceRequest) (*milvuspb.DescribeNamespaceResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeNamespace is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DescribeNamespaceRequest
func (_e *MilvusServiceServer_Expecter) DescribeNamespace(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DescribeNamespace_Call {
	return &MilvusServiceServer_DescribeNamespace_Call{Call: _e.mock.On("DescribeNamespace", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_DescribeNamespace_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribeNamespaceRequest) (*milvuspb.DescribeNamespaceResponse, error)) *MilvusServiceServer_DescribeNamespace_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePrewarmTask provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) DescribePrewarmTask(_a0 context.Context, _a1 *milvuspb.DescribePrewarmTaskRequest) (*milvuspb.DescribePrewarmTaskResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribePrewarmTask is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DescribePrewarmTaskRequest
func (_e *MilvusServiceServer_Expecter) DescribePrewarmTask(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DescribePrewarmTask_Call {
	return &MilvusServiceServer_DescribePrewarmTask_Call{Call: _e.mock.On("DescribePrewarmTask", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_DescribePrewarmTask_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribePrewarmTaskRequest) (*milvuspb.DescribePrewarmTaskResponse, error)) *MilvusServiceServer_DescribePrewarmTask_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// DescribeSegmentIndexData provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) DescribeSegmentIndexData(_a0 context.Context, _a1 *federpb.DescribeSegmentIndexDataRequest) (*federpb.DescribeSegmentIndexDataResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DescribeSegmentIndexData is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *federpb.DescribeSegmentIndexDataRequest
func (_e *MilvusServiceServer_Expecter) DescribeSegmentIndexData(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DescribeSegmentIndexData_Call {
	return &MilvusServiceServer_DescribeSegmentIndexData_Call{Call: _e.mock.On("DescribeSegmentIndexData", _a0, _a1)}
}

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

func (_c *MilvusServiceServer_DescribeSegmentIndexData_Call) Return(_a0 *federpb.DescribeSegmentIndexDataResponse, _a1 error) *MilvusServiceServer_DescribeSegmentIndexData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_DescribeSegmentIndexData_Call) RunAndReturn(run func(context.Context, *federpb.DescribeSegmentIndexDataRequest) (*federpb.DescribeSegmentIndexDataResponse, error)) *MilvusServiceServer_DescribeSegmentIndexData_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// DropNamespace provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) DropNamespace(_a0 context.Context, _a1 *milvuspb.DropNamespaceRequest) (*milvuspb.DropNamespaceResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// DropNamespace is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropNamespaceRequest
func (_e *MilvusServiceServer_Expecter) DropNamespace(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DropNamespace_Call {
	return &MilvusServiceServer_DropNamespace_Call{Call: _e.mock.On("DropNamespace", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_DropNamespace_Call) RunAndReturn(run func(context.Context, *milvuspb.DropNamespaceRequest) (*milvuspb.DropNamespaceResponse, error)) *MilvusServiceServer_DropNamespace_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// DropRowPolicy is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DropRowPolicyRequest
func (_e *MilvusServiceServer_Expecter) DropRowPolicy(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DropRowPolicy_Call {
	return &MilvusServiceServer_DropRowPolicy_Call{Call: _e.mock.On("DropRowPolicy", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// Dummy provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Dummy(_a0 context.Context, _a1 *milvuspb.DummyRequest) (*milvuspb.DummyResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// Dummy is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.DummyRequest
func (_e *MilvusServiceServer_Expecter) Dummy(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Dummy_Call {
	return &MilvusServiceServer_Dummy_Call{Call: _e.mock.On("Dummy", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_Dummy_Call) RunAndReturn(run func(context.Context, *milvuspb.DummyRequest) (*milvuspb.DummyResponse, error)) *MilvusServiceServer_Dummy_Call {
	_c.Call.Return(run)
	return _c
}

// DumpMessages provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) DumpMessages(_a0 *milvuspb.DumpMessagesRequest, _a1 milvuspb.MilvusService_DumpMessagesServer) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*milvuspb.DumpMessagesRequest, milvuspb.MilvusService_DumpMessagesServer) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DumpMessages is a helper method to define mock.On call
//   - _a0 *milvuspb.DumpMessagesRequest
//   - _a1 milvuspb.MilvusService_DumpMessagesServer
func (_e *MilvusServiceServer_Expecter) DumpMessages(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_DumpMessages_Call {
	return &MilvusServiceServer_DumpMessages_Call{Call: _e.mock.On("DumpMessages", _a0, _a1)}
}

func (_c *MilvusServiceServer_DumpMessages_Call) Run(run func(_a0 *milvuspb.DumpMessagesRequest, _a1 milvuspb.MilvusService_DumpMessagesServer)) *MilvusServiceServer_DumpMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*milvuspb.DumpMessagesRequest), args[1].(milvuspb.MilvusService_DumpMessagesServer))
	})
	return _c
}

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

func (_c *MilvusServiceServer_DumpMessages_Call) RunAndReturn(run func(*milvuspb.DumpMessagesRequest, milvuspb.MilvusService_DumpMessagesServer) error) *MilvusServiceServer_DumpMessages_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// GetImportState provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetImportState(_a0 context.Context, _a1 *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetImportState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetImportStateRequest
func (_e *MilvusServiceServer_Expecter) GetImportState(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetImportState_Call {
	return &MilvusServiceServer_GetImportState_Call{Call: _e.mock.On("GetImportState", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetImportState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error)) *MilvusServiceServer_GetImportState_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// GetLoadState provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetLoadState(_a0 context.Context, _a1 *milvuspb.GetLoadStateRequest) (*milvuspb.GetLoadStateResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetLoadState is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetLoadStateRequest
func (_e *MilvusServiceServer_Expecter) GetLoadState(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetLoadState_Call {
	return &MilvusServiceServer_GetLoadState_Call{Call: _e.mock.On("GetLoadState", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetLoadState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetLoadStateRequest) (*milvuspb.GetLoadStateResponse, error)) *MilvusServiceServer_GetLoadState_Call {
	_c.Call.Return(run)
	return _c
}

// GetLoadingProgress provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetLoadingProgress(_a0 context.Context, _a1 *milvuspb.GetLoadingProgressRequest) (*milvuspb.GetLoadingProgressResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetLoadingProgress is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetLoadingProgressRequest
func (_e *MilvusServiceServer_Expecter) GetLoadingProgress(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetLoadingProgress_Call {
	return &MilvusServiceServer_GetLoadingProgress_Call{Call: _e.mock.On("GetLoadingProgress", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetLoadingProgress_Call) RunAndReturn(run func(context.Context, *milvuspb.GetLoadingProgressRequest) (*milvuspb.GetLoadingProgressResponse, error)) *MilvusServiceServer_GetLoadingProgress_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// GetNamespaceStats provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetNamespaceStats(_a0 context.Context, _a1 *milvuspb.GetNamespaceStatsRequest) (*milvuspb.GetNamespaceStatsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetNamespaceStats is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetNamespaceStatsRequest
func (_e *MilvusServiceServer_Expecter) GetNamespaceStats(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetNamespaceStats_Call {
	return &MilvusServiceServer_GetNamespaceStats_Call{Call: _e.mock.On("GetNamespaceStats", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetNamespaceStats_Call) RunAndReturn(run func(context.Context, *milvuspb.GetNamespaceStatsRequest) (*milvuspb.GetNamespaceStatsResponse, error)) *MilvusServiceServer_GetNamespaceStats_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// GetPersistentSegmentInfo provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetPersistentSegmentInfo(_a0 context.Context, _a1 *milvuspb.GetPersistentSegmentInfoRequest) (*milvuspb.GetPersistentSegmentInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetPersistentSegmentInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetPersistentSegmentInfoRequest
func (_e *MilvusServiceServer_Expecter) GetPersistentSegmentInfo(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetPersistentSegmentInfo_Call {
	return &MilvusServiceServer_GetPersistentSegmentInfo_Call{Call: _e.mock.On("GetPersistentSegmentInfo", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetPersistentSegmentInfo_Call) RunAndReturn(run func(context.Context, *milvuspb.GetPersistentSegmentInfoRequest) (*milvuspb.GetPersistentSegmentInfoResponse, error)) *MilvusServiceServer_GetPersistentSegmentInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetQuerySegmentInfo provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetQuerySegmentInfo(_a0 context.Context, _a1 *milvuspb.GetQuerySegmentInfoRequest) (*milvuspb.GetQuerySegmentInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetQuerySegmentInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetQuerySegmentInfoRequest
func (_e *MilvusServiceServer_Expecter) GetQuerySegmentInfo(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetQuerySegmentInfo_Call {
	return &MilvusServiceServer_GetQuerySegmentInfo_Call{Call: _e.mock.On("GetQuerySegmentInfo", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetQuerySegmentInfo_Call) RunAndReturn(run func(context.Context, *milvuspb.GetQuerySegmentInfoRequest) (*milvuspb.GetQuerySegmentInfoResponse, error)) *MilvusServiceServer_GetQuerySegmentInfo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// GetReplicateConfiguration provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetReplicateConfiguration(_a0 context.Context, _a1 *milvuspb.GetReplicateConfigurationRequest) (*milvuspb.GetReplicateConfigurationResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetReplicateConfiguration is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetReplicateConfigurationRequest
func (_e *MilvusServiceServer_Expecter) GetReplicateConfiguration(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetReplicateConfiguration_Call {
	return &MilvusServiceServer_GetReplicateConfiguration_Call{Call: _e.mock.On("GetReplicateConfiguration", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetReplicateConfiguration_Call) RunAndReturn(run func(context.Context, *milvuspb.GetReplicateConfigurationRequest) (*milvuspb.GetReplicateConfigurationResponse, error)) *MilvusServiceServer_GetReplicateConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetReplicateInfo provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetReplicateInfo(_a0 context.Context, _a1 *milvuspb.GetReplicateInfoRequest) (*milvuspb.GetReplicateInfoResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetReplicateInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetReplicateInfoRequest
func (_e *MilvusServiceServer_Expecter) GetReplicateInfo(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetReplicateInfo_Call {
	return &MilvusServiceServer_GetReplicateInfo_Call{Call: _e.mock.On("GetReplicateInfo", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetReplicateInfo_Call) RunAndReturn(run func(context.Context, *milvuspb.GetReplicateInfoRequest) (*milvuspb.GetReplicateInfoResponse, error)) *MilvusServiceServer_GetReplicateInfo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// GetUserTags provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetUserTags(_a0 context.Context, _a1 *milvuspb.GetUserTagsRequest) (*milvuspb.GetUserTagsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetUserTags is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetUserTagsRequest
func (_e *MilvusServiceServer_Expecter) GetUserTags(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetUserTags_Call {
	return &MilvusServiceServer_GetUserTags_Call{Call: _e.mock.On("GetUserTags", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetUserTags_Call) RunAndReturn(run func(context.Context, *milvuspb.GetUserTagsRequest) (*milvuspb.GetUserTagsResponse, error)) *MilvusServiceServer_GetUserTags_Call {
	_c.Call.Return(run)
	return _c
}

// GetVersion provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) GetVersion(_a0 context.Context, _a1 *milvuspb.GetVersionRequest) (*milvuspb.GetVersionResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// GetVersion is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.GetVersionRequest
func (_e *MilvusServiceServer_Expecter) GetVersion(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_GetVersion_Call {
	return &MilvusServiceServer_GetVersion_Call{Call: _e.mock.On("GetVersion", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_GetVersion_Call) RunAndReturn(run func(context.Context, *milvuspb.GetVersionRequest) (*milvuspb.GetVersionResponse, error)) *MilvusServiceServer_GetVersion_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// HasNamespace provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) HasNamespace(_a0 context.Context, _a1 *milvuspb.HasNamespaceRequest) (*milvuspb.HasNamespaceResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// HasNamespace is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.HasNamespaceRequest
func (_e *MilvusServiceServer_Expecter) HasNamespace(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_HasNamespace_Call {
	return &MilvusServiceServer_HasNamespace_Call{Call: _e.mock.On("HasNamespace", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_HasNamespace_Call) RunAndReturn(run func(context.Context, *milvuspb.HasNamespaceRequest) (*milvuspb.HasNamespaceResponse, error)) *MilvusServiceServer_HasNamespace_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// HybridSearch provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) HybridSearch(_a0 context.Context, _a1 *milvuspb.HybridSearchRequest) (*milvuspb.SearchResults, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// HybridSearch is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.HybridSearchRequest
func (_e *MilvusServiceServer_Expecter) HybridSearch(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_HybridSearch_Call {
	return &MilvusServiceServer_HybridSearch_Call{Call: _e.mock.On("HybridSearch", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_HybridSearch_Call) RunAndReturn(run func(context.Context, *milvuspb.HybridSearchRequest) (*milvuspb.SearchResults, error)) *MilvusServiceServer_HybridSearch_Call {
	_c.Call.Return(run)
	return _c
}

// Import provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Import(_a0 context.Context, _a1 *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// Import is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ImportRequest
func (_e *MilvusServiceServer_Expecter) Import(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Import_Call {
	return &MilvusServiceServer_Import_Call{Call: _e.mock.On("Import", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_Import_Call) RunAndReturn(run func(context.Context, *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error)) *MilvusServiceServer_Import_Call {
	_c.Call.Return(run)
	return _c
}

// Insert provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Insert(_a0 context.Context, _a1 *milvuspb.InsertRequest) (*milvuspb.MutationResult, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// Insert is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.InsertRequest
func (_e *MilvusServiceServer_Expecter) Insert(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Insert_Call {
	return &MilvusServiceServer_Insert_Call{Call: _e.mock.On("Insert", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_Insert_Call) RunAndReturn(run func(context.Context, *milvuspb.InsertRequest) (*milvuspb.MutationResult, error)) *MilvusServiceServer_Insert_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// ListImportTasks provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListImportTasks(_a0 context.Context, _a1 *milvuspb.ListImportTasksRequest) (*milvuspb.ListImportTasksResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListImportTasks is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListImportTasksRequest
func (_e *MilvusServiceServer_Expecter) ListImportTasks(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListImportTasks_Call {
	return &MilvusServiceServer_ListImportTasks_Call{Call: _e.mock.On("ListImportTasks", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_ListImportTasks_Call) RunAndReturn(run func(context.Context, *milvuspb.ListImportTasksRequest) (*milvuspb.ListImportTasksResponse, error)) *MilvusServiceServer_ListImportTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ListIndexedSegment provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListIndexedSegment(_a0 context.Context, _a1 *federpb.ListIndexedSegmentRequest) (*federpb.ListIndexedSegmentResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListIndexedSegment is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *federpb.ListIndexedSegmentRequest
func (_e *MilvusServiceServer_Expecter) ListIndexedSegment(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListIndexedSegment_Call {
	return &MilvusServiceServer_ListIndexedSegment_Call{Call: _e.mock.On("ListIndexedSegment", _a0, _a1)}
}

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

func (_c *MilvusServiceServer_ListIndexedSegment_Call) Return(_a0 *federpb.ListIndexedSegmentResponse, _a1 error) *MilvusServiceServer_ListIndexedSegment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListIndexedSegment_Call) RunAndReturn(run func(context.Context, *federpb.ListIndexedSegmentRequest) (*federpb.ListIndexedSegmentResponse, error)) *MilvusServiceServer_ListIndexedSegment_Call {
	_c.Call.Return(run)
	return _c
}

// ListNamespaces provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListNamespaces(_a0 context.Context, _a1 *milvuspb.ListNamespacesRequest) (*milvuspb.ListNamespacesResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ListNamespaces is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListNamespacesRequest
func (_e *MilvusServiceServer_Expecter) ListNamespaces(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListNamespaces_Call {
	return &MilvusServiceServer_ListNamespaces_Call{Call: _e.mock.On("ListNamespaces", _a0, _a1)}
}

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

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

func (_c *MilvusServiceServer_ListNamespaces_Call) RunAndReturn(run func(context.Context, *milvuspb.ListNamespacesRequest) (*milvuspb.ListNamespacesResponse, error)) *MilvusServiceServer_ListNamespaces_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

// ListPrivilegeGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListPrivilegeGroupsRequest
func (_e *MilvusServiceServer_Expecter) ListPrivilegeGroups(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListPrivilegeGroups_Call {
	return &MilvusServiceServer_ListPrivilegeGroups_Call{Call: _e.mock.On("ListPrivilegeGroups", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListPrivilegeGroups_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListPrivilegeGroupsRequest)) *MilvusServiceServer_ListPrivilegeGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListPrivilegeGroupsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListPrivilegeGroups_Call) Return(_a0 *milvuspb.ListPrivilegeGroupsResponse, _a1 error) *MilvusServiceServer_ListPrivilegeGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListPrivilegeGroups_Call) RunAndReturn(run func(context.Context, *milvuspb.ListPrivilegeGroupsRequest) (*milvuspb.ListPrivilegeGroupsResponse, error)) *MilvusServiceServer_ListPrivilegeGroups_Call {
	_c.Call.Return(run)
	return _c
}

// ListRefreshExternalCollectionJobs provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListRefreshExternalCollectionJobs(_a0 context.Context, _a1 *milvuspb.ListRefreshExternalCollectionJobsRequest) (*milvuspb.ListRefreshExternalCollectionJobsResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ListRefreshExternalCollectionJobs")
	}

	var r0 *milvuspb.ListRefreshExternalCollectionJobsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListRefreshExternalCollectionJobsRequest) (*milvuspb.ListRefreshExternalCollectionJobsResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListRefreshExternalCollectionJobsRequest) *milvuspb.ListRefreshExternalCollectionJobsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListRefreshExternalCollectionJobsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListRefreshExternalCollectionJobsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ListRefreshExternalCollectionJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRefreshExternalCollectionJobs'
type MilvusServiceServer_ListRefreshExternalCollectionJobs_Call struct {
	*mock.Call
}

// ListRefreshExternalCollectionJobs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListRefreshExternalCollectionJobsRequest
func (_e *MilvusServiceServer_Expecter) ListRefreshExternalCollectionJobs(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call {
	return &MilvusServiceServer_ListRefreshExternalCollectionJobs_Call{Call: _e.mock.On("ListRefreshExternalCollectionJobs", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListRefreshExternalCollectionJobsRequest)) *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListRefreshExternalCollectionJobsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call) Return(_a0 *milvuspb.ListRefreshExternalCollectionJobsResponse, _a1 error) *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call) RunAndReturn(run func(context.Context, *milvuspb.ListRefreshExternalCollectionJobsRequest) (*milvuspb.ListRefreshExternalCollectionJobsResponse, error)) *MilvusServiceServer_ListRefreshExternalCollectionJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceGroups provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListResourceGroups(_a0 context.Context, _a1 *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ListResourceGroups")
	}

	var r0 *milvuspb.ListResourceGroupsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest) *milvuspb.ListResourceGroupsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListResourceGroupsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListResourceGroupsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ListResourceGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListResourceGroups'
type MilvusServiceServer_ListResourceGroups_Call struct {
	*mock.Call
}

// ListResourceGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListResourceGroupsRequest
func (_e *MilvusServiceServer_Expecter) ListResourceGroups(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListResourceGroups_Call {
	return &MilvusServiceServer_ListResourceGroups_Call{Call: _e.mock.On("ListResourceGroups", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListResourceGroups_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListResourceGroupsRequest)) *MilvusServiceServer_ListResourceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListResourceGroupsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListResourceGroups_Call) Return(_a0 *milvuspb.ListResourceGroupsResponse, _a1 error) *MilvusServiceServer_ListResourceGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListResourceGroups_Call) RunAndReturn(run func(context.Context, *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error)) *MilvusServiceServer_ListResourceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// ListRestoreSnapshotJobs provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListRestoreSnapshotJobs(_a0 context.Context, _a1 *milvuspb.ListRestoreSnapshotJobsRequest) (*milvuspb.ListRestoreSnapshotJobsResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ListRestoreSnapshotJobs")
	}

	var r0 *milvuspb.ListRestoreSnapshotJobsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListRestoreSnapshotJobsRequest) (*milvuspb.ListRestoreSnapshotJobsResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListRestoreSnapshotJobsRequest) *milvuspb.ListRestoreSnapshotJobsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListRestoreSnapshotJobsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListRestoreSnapshotJobsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ListRestoreSnapshotJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRestoreSnapshotJobs'
type MilvusServiceServer_ListRestoreSnapshotJobs_Call struct {
	*mock.Call
}

// ListRestoreSnapshotJobs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListRestoreSnapshotJobsRequest
func (_e *MilvusServiceServer_Expecter) ListRestoreSnapshotJobs(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListRestoreSnapshotJobs_Call {
	return &MilvusServiceServer_ListRestoreSnapshotJobs_Call{Call: _e.mock.On("ListRestoreSnapshotJobs", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListRestoreSnapshotJobs_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListRestoreSnapshotJobsRequest)) *MilvusServiceServer_ListRestoreSnapshotJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListRestoreSnapshotJobsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListRestoreSnapshotJobs_Call) Return(_a0 *milvuspb.ListRestoreSnapshotJobsResponse, _a1 error) *MilvusServiceServer_ListRestoreSnapshotJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListRestoreSnapshotJobs_Call) RunAndReturn(run func(context.Context, *milvuspb.ListRestoreSnapshotJobsRequest) (*milvuspb.ListRestoreSnapshotJobsResponse, error)) *MilvusServiceServer_ListRestoreSnapshotJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListRowPolicies provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListRowPolicies(_a0 context.Context, _a1 *milvuspb.ListRowPoliciesRequest) (*milvuspb.ListRowPoliciesResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ListRowPolicies")
	}

	var r0 *milvuspb.ListRowPoliciesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListRowPoliciesRequest) (*milvuspb.ListRowPoliciesResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListRowPoliciesRequest) *milvuspb.ListRowPoliciesResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListRowPoliciesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListRowPoliciesRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ListRowPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRowPolicies'
type MilvusServiceServer_ListRowPolicies_Call struct {
	*mock.Call
}

// ListRowPolicies is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListRowPoliciesRequest
func (_e *MilvusServiceServer_Expecter) ListRowPolicies(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListRowPolicies_Call {
	return &MilvusServiceServer_ListRowPolicies_Call{Call: _e.mock.On("ListRowPolicies", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListRowPolicies_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListRowPoliciesRequest)) *MilvusServiceServer_ListRowPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListRowPoliciesRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListRowPolicies_Call) Return(_a0 *milvuspb.ListRowPoliciesResponse, _a1 error) *MilvusServiceServer_ListRowPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListRowPolicies_Call) RunAndReturn(run func(context.Context, *milvuspb.ListRowPoliciesRequest) (*milvuspb.ListRowPoliciesResponse, error)) *MilvusServiceServer_ListRowPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// ListSnapshots provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListSnapshots(_a0 context.Context, _a1 *milvuspb.ListSnapshotsRequest) (*milvuspb.ListSnapshotsResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ListSnapshots")
	}

	var r0 *milvuspb.ListSnapshotsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListSnapshotsRequest) (*milvuspb.ListSnapshotsResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListSnapshotsRequest) *milvuspb.ListSnapshotsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListSnapshotsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListSnapshotsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ListSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSnapshots'
type MilvusServiceServer_ListSnapshots_Call struct {
	*mock.Call
}

// ListSnapshots is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListSnapshotsRequest
func (_e *MilvusServiceServer_Expecter) ListSnapshots(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListSnapshots_Call {
	return &MilvusServiceServer_ListSnapshots_Call{Call: _e.mock.On("ListSnapshots", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListSnapshots_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListSnapshotsRequest)) *MilvusServiceServer_ListSnapshots_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListSnapshotsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListSnapshots_Call) Return(_a0 *milvuspb.ListSnapshotsResponse, _a1 error) *MilvusServiceServer_ListSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListSnapshots_Call) RunAndReturn(run func(context.Context, *milvuspb.ListSnapshotsRequest) (*milvuspb.ListSnapshotsResponse, error)) *MilvusServiceServer_ListSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsersWithTag provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ListUsersWithTag(_a0 context.Context, _a1 *milvuspb.ListUsersWithTagRequest) (*milvuspb.ListUsersWithTagResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ListUsersWithTag")
	}

	var r0 *milvuspb.ListUsersWithTagResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListUsersWithTagRequest) (*milvuspb.ListUsersWithTagResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListUsersWithTagRequest) *milvuspb.ListUsersWithTagResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListUsersWithTagResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListUsersWithTagRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ListUsersWithTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsersWithTag'
type MilvusServiceServer_ListUsersWithTag_Call struct {
	*mock.Call
}

// ListUsersWithTag is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ListUsersWithTagRequest
func (_e *MilvusServiceServer_Expecter) ListUsersWithTag(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ListUsersWithTag_Call {
	return &MilvusServiceServer_ListUsersWithTag_Call{Call: _e.mock.On("ListUsersWithTag", _a0, _a1)}
}

func (_c *MilvusServiceServer_ListUsersWithTag_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListUsersWithTagRequest)) *MilvusServiceServer_ListUsersWithTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ListUsersWithTagRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ListUsersWithTag_Call) Return(_a0 *milvuspb.ListUsersWithTagResponse, _a1 error) *MilvusServiceServer_ListUsersWithTag_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ListUsersWithTag_Call) RunAndReturn(run func(context.Context, *milvuspb.ListUsersWithTagRequest) (*milvuspb.ListUsersWithTagResponse, error)) *MilvusServiceServer_ListUsersWithTag_Call {
	_c.Call.Return(run)
	return _c
}

// LoadBalance provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) LoadBalance(_a0 context.Context, _a1 *milvuspb.LoadBalanceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for LoadBalance")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.LoadBalanceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.LoadBalanceRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.LoadBalanceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_LoadBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadBalance'
type MilvusServiceServer_LoadBalance_Call struct {
	*mock.Call
}

// LoadBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.LoadBalanceRequest
func (_e *MilvusServiceServer_Expecter) LoadBalance(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_LoadBalance_Call {
	return &MilvusServiceServer_LoadBalance_Call{Call: _e.mock.On("LoadBalance", _a0, _a1)}
}

func (_c *MilvusServiceServer_LoadBalance_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.LoadBalanceRequest)) *MilvusServiceServer_LoadBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.LoadBalanceRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_LoadBalance_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_LoadBalance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_LoadBalance_Call) RunAndReturn(run func(context.Context, *milvuspb.LoadBalanceRequest) (*commonpb.Status, error)) *MilvusServiceServer_LoadBalance_Call {
	_c.Call.Return(run)
	return _c
}

// LoadCollection provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) LoadCollection(_a0 context.Context, _a1 *milvuspb.LoadCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for LoadCollection")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.LoadCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.LoadCollectionRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.LoadCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_LoadCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadCollection'
type MilvusServiceServer_LoadCollection_Call struct {
	*mock.Call
}

// LoadCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.LoadCollectionRequest
func (_e *MilvusServiceServer_Expecter) LoadCollection(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_LoadCollection_Call {
	return &MilvusServiceServer_LoadCollection_Call{Call: _e.mock.On("LoadCollection", _a0, _a1)}
}

func (_c *MilvusServiceServer_LoadCollection_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.LoadCollectionRequest)) *MilvusServiceServer_LoadCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.LoadCollectionRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_LoadCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_LoadCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_LoadCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.LoadCollectionRequest) (*commonpb.Status, error)) *MilvusServiceServer_LoadCollection_Call {
	_c.Call.Return(run)
	return _c
}

// LoadPartitions provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) LoadPartitions(_a0 context.Context, _a1 *milvuspb.LoadPartitionsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for LoadPartitions")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.LoadPartitionsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.LoadPartitionsRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.LoadPartitionsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_LoadPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadPartitions'
type MilvusServiceServer_LoadPartitions_Call struct {
	*mock.Call
}

// LoadPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.LoadPartitionsRequest
func (_e *MilvusServiceServer_Expecter) LoadPartitions(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_LoadPartitions_Call {
	return &MilvusServiceServer_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions", _a0, _a1)}
}

func (_c *MilvusServiceServer_LoadPartitions_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.LoadPartitionsRequest)) *MilvusServiceServer_LoadPartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.LoadPartitionsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_LoadPartitions_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_LoadPartitions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_LoadPartitions_Call) RunAndReturn(run func(context.Context, *milvuspb.LoadPartitionsRequest) (*commonpb.Status, error)) *MilvusServiceServer_LoadPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// ManualCompaction provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ManualCompaction(_a0 context.Context, _a1 *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ManualCompaction")
	}

	var r0 *milvuspb.ManualCompactionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) *milvuspb.ManualCompactionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ManualCompactionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ManualCompactionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ManualCompaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManualCompaction'
type MilvusServiceServer_ManualCompaction_Call struct {
	*mock.Call
}

// ManualCompaction is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ManualCompactionRequest
func (_e *MilvusServiceServer_Expecter) ManualCompaction(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ManualCompaction_Call {
	return &MilvusServiceServer_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction", _a0, _a1)}
}

func (_c *MilvusServiceServer_ManualCompaction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ManualCompactionRequest)) *MilvusServiceServer_ManualCompaction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ManualCompactionRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ManualCompaction_Call) Return(_a0 *milvuspb.ManualCompactionResponse, _a1 error) *MilvusServiceServer_ManualCompaction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ManualCompaction_Call) RunAndReturn(run func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)) *MilvusServiceServer_ManualCompaction_Call {
	_c.Call.Return(run)
	return _c
}

// OperatePrivilege provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) OperatePrivilege(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for OperatePrivilege")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperatePrivilegeRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_OperatePrivilege_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatePrivilege'
type MilvusServiceServer_OperatePrivilege_Call struct {
	*mock.Call
}

// OperatePrivilege is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperatePrivilegeRequest
func (_e *MilvusServiceServer_Expecter) OperatePrivilege(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_OperatePrivilege_Call {
	return &MilvusServiceServer_OperatePrivilege_Call{Call: _e.mock.On("OperatePrivilege", _a0, _a1)}
}

func (_c *MilvusServiceServer_OperatePrivilege_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeRequest)) *MilvusServiceServer_OperatePrivilege_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.OperatePrivilegeRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_OperatePrivilege_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_OperatePrivilege_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_OperatePrivilege_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)) *MilvusServiceServer_OperatePrivilege_Call {
	_c.Call.Return(run)
	return _c
}

// OperatePrivilegeGroup provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) OperatePrivilegeGroup(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for OperatePrivilegeGroup")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_OperatePrivilegeGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatePrivilegeGroup'
type MilvusServiceServer_OperatePrivilegeGroup_Call struct {
	*mock.Call
}

// OperatePrivilegeGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperatePrivilegeGroupRequest
func (_e *MilvusServiceServer_Expecter) OperatePrivilegeGroup(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_OperatePrivilegeGroup_Call {
	return &MilvusServiceServer_OperatePrivilegeGroup_Call{Call: _e.mock.On("OperatePrivilegeGroup", _a0, _a1)}
}

func (_c *MilvusServiceServer_OperatePrivilegeGroup_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeGroupRequest)) *MilvusServiceServer_OperatePrivilegeGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.OperatePrivilegeGroupRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_OperatePrivilegeGroup_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_OperatePrivilegeGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_OperatePrivilegeGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeGroupRequest) (*commonpb.Status, error)) *MilvusServiceServer_OperatePrivilegeGroup_Call {
	_c.Call.Return(run)
	return _c
}

// OperatePrivilegeV2 provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) OperatePrivilegeV2(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeV2Request) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for OperatePrivilegeV2")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeV2Request) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeV2Request) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperatePrivilegeV2Request) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_OperatePrivilegeV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatePrivilegeV2'
type MilvusServiceServer_OperatePrivilegeV2_Call struct {
	*mock.Call
}

// OperatePrivilegeV2 is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperatePrivilegeV2Request
func (_e *MilvusServiceServer_Expecter) OperatePrivilegeV2(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_OperatePrivilegeV2_Call {
	return &MilvusServiceServer_OperatePrivilegeV2_Call{Call: _e.mock.On("OperatePrivilegeV2", _a0, _a1)}
}

func (_c *MilvusServiceServer_OperatePrivilegeV2_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeV2Request)) *MilvusServiceServer_OperatePrivilegeV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.OperatePrivilegeV2Request))
	})
	return _c
}

func (_c *MilvusServiceServer_OperatePrivilegeV2_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_OperatePrivilegeV2_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_OperatePrivilegeV2_Call) RunAndReturn(run func(context.Context, *milvuspb.OperatePrivilegeV2Request) (*commonpb.Status, error)) *MilvusServiceServer_OperatePrivilegeV2_Call {
	_c.Call.Return(run)
	return _c
}

// OperateUserRole provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) OperateUserRole(_a0 context.Context, _a1 *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for OperateUserRole")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperateUserRoleRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_OperateUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperateUserRole'
type MilvusServiceServer_OperateUserRole_Call struct {
	*mock.Call
}

// OperateUserRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.OperateUserRoleRequest
func (_e *MilvusServiceServer_Expecter) OperateUserRole(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_OperateUserRole_Call {
	return &MilvusServiceServer_OperateUserRole_Call{Call: _e.mock.On("OperateUserRole", _a0, _a1)}
}

func (_c *MilvusServiceServer_OperateUserRole_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.OperateUserRoleRequest)) *MilvusServiceServer_OperateUserRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.OperateUserRoleRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_OperateUserRole_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_OperateUserRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_OperateUserRole_Call) RunAndReturn(run func(context.Context, *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error)) *MilvusServiceServer_OperateUserRole_Call {
	_c.Call.Return(run)
	return _c
}

// PinSnapshotData provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) PinSnapshotData(_a0 context.Context, _a1 *milvuspb.PinSnapshotDataRequest) (*milvuspb.PinSnapshotDataResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for PinSnapshotData")
	}

	var r0 *milvuspb.PinSnapshotDataResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.PinSnapshotDataRequest) (*milvuspb.PinSnapshotDataResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.PinSnapshotDataRequest) *milvuspb.PinSnapshotDataResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.PinSnapshotDataResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.PinSnapshotDataRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_PinSnapshotData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PinSnapshotData'
type MilvusServiceServer_PinSnapshotData_Call struct {
	*mock.Call
}

// PinSnapshotData is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.PinSnapshotDataRequest
func (_e *MilvusServiceServer_Expecter) PinSnapshotData(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_PinSnapshotData_Call {
	return &MilvusServiceServer_PinSnapshotData_Call{Call: _e.mock.On("PinSnapshotData", _a0, _a1)}
}

func (_c *MilvusServiceServer_PinSnapshotData_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.PinSnapshotDataRequest)) *MilvusServiceServer_PinSnapshotData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.PinSnapshotDataRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_PinSnapshotData_Call) Return(_a0 *milvuspb.PinSnapshotDataResponse, _a1 error) *MilvusServiceServer_PinSnapshotData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_PinSnapshotData_Call) RunAndReturn(run func(context.Context, *milvuspb.PinSnapshotDataRequest) (*milvuspb.PinSnapshotDataResponse, error)) *MilvusServiceServer_PinSnapshotData_Call {
	_c.Call.Return(run)
	return _c
}

// Prewarm provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Prewarm(_a0 context.Context, _a1 *milvuspb.PrewarmRequest) (*milvuspb.PrewarmResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for Prewarm")
	}

	var r0 *milvuspb.PrewarmResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.PrewarmRequest) (*milvuspb.PrewarmResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.PrewarmRequest) *milvuspb.PrewarmResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.PrewarmResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.PrewarmRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
type MilvusServiceServer_Prewarm_Call struct {
	*mock.Call
}

// Prewarm is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.PrewarmRequest
func (_e *MilvusServiceServer_Expecter) Prewarm(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Prewarm_Call {
	return &MilvusServiceServer_Prewarm_Call{Call: _e.mock.On("Prewarm", _a0, _a1)}
}

func (_c *MilvusServiceServer_Prewarm_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.PrewarmRequest)) *MilvusServiceServer_Prewarm_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.PrewarmRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_Prewarm_Call) Return(_a0 *milvuspb.PrewarmResponse, _a1 error) *MilvusServiceServer_Prewarm_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_Prewarm_Call) RunAndReturn(run func(context.Context, *milvuspb.PrewarmRequest) (*milvuspb.PrewarmResponse, error)) *MilvusServiceServer_Prewarm_Call {
	_c.Call.Return(run)
	return _c
}

// Query provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Query(_a0 context.Context, _a1 *milvuspb.QueryRequest) (*milvuspb.QueryResults, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for Query")
	}

	var r0 *milvuspb.QueryResults
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.QueryRequest) (*milvuspb.QueryResults, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.QueryRequest) *milvuspb.QueryResults); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.QueryResults)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.QueryRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query'
type MilvusServiceServer_Query_Call struct {
	*mock.Call
}

// Query is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.QueryRequest
func (_e *MilvusServiceServer_Expecter) Query(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Query_Call {
	return &MilvusServiceServer_Query_Call{Call: _e.mock.On("Query", _a0, _a1)}
}

func (_c *MilvusServiceServer_Query_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.QueryRequest)) *MilvusServiceServer_Query_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.QueryRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_Query_Call) Return(_a0 *milvuspb.QueryResults, _a1 error) *MilvusServiceServer_Query_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_Query_Call) RunAndReturn(run func(context.Context, *milvuspb.QueryRequest) (*milvuspb.QueryResults, error)) *MilvusServiceServer_Query_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshExternalCollection provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RefreshExternalCollection(_a0 context.Context, _a1 *milvuspb.RefreshExternalCollectionRequest) (*milvuspb.RefreshExternalCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RefreshExternalCollection")
	}

	var r0 *milvuspb.RefreshExternalCollectionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RefreshExternalCollectionRequest) (*milvuspb.RefreshExternalCollectionResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RefreshExternalCollectionRequest) *milvuspb.RefreshExternalCollectionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.RefreshExternalCollectionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RefreshExternalCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RefreshExternalCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshExternalCollection'
type MilvusServiceServer_RefreshExternalCollection_Call struct {
	*mock.Call
}

// RefreshExternalCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RefreshExternalCollectionRequest
func (_e *MilvusServiceServer_Expecter) RefreshExternalCollection(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RefreshExternalCollection_Call {
	return &MilvusServiceServer_RefreshExternalCollection_Call{Call: _e.mock.On("RefreshExternalCollection", _a0, _a1)}
}

func (_c *MilvusServiceServer_RefreshExternalCollection_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RefreshExternalCollectionRequest)) *MilvusServiceServer_RefreshExternalCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RefreshExternalCollectionRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RefreshExternalCollection_Call) Return(_a0 *milvuspb.RefreshExternalCollectionResponse, _a1 error) *MilvusServiceServer_RefreshExternalCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RefreshExternalCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.RefreshExternalCollectionRequest) (*milvuspb.RefreshExternalCollectionResponse, error)) *MilvusServiceServer_RefreshExternalCollection_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterLink provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RegisterLink(_a0 context.Context, _a1 *milvuspb.RegisterLinkRequest) (*milvuspb.RegisterLinkResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RegisterLink")
	}

	var r0 *milvuspb.RegisterLinkResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RegisterLinkRequest) (*milvuspb.RegisterLinkResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RegisterLinkRequest) *milvuspb.RegisterLinkResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.RegisterLinkResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RegisterLinkRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RegisterLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterLink'
type MilvusServiceServer_RegisterLink_Call struct {
	*mock.Call
}

// RegisterLink is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RegisterLinkRequest
func (_e *MilvusServiceServer_Expecter) RegisterLink(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RegisterLink_Call {
	return &MilvusServiceServer_RegisterLink_Call{Call: _e.mock.On("RegisterLink", _a0, _a1)}
}

func (_c *MilvusServiceServer_RegisterLink_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RegisterLinkRequest)) *MilvusServiceServer_RegisterLink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RegisterLinkRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RegisterLink_Call) Return(_a0 *milvuspb.RegisterLinkResponse, _a1 error) *MilvusServiceServer_RegisterLink_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RegisterLink_Call) RunAndReturn(run func(context.Context, *milvuspb.RegisterLinkRequest) (*milvuspb.RegisterLinkResponse, error)) *MilvusServiceServer_RegisterLink_Call {
	_c.Call.Return(run)
	return _c
}

// ReleaseCollection provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ReleaseCollection(_a0 context.Context, _a1 *milvuspb.ReleaseCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ReleaseCollection")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ReleaseCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ReleaseCollectionRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ReleaseCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ReleaseCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseCollection'
type MilvusServiceServer_ReleaseCollection_Call struct {
	*mock.Call
}

// ReleaseCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ReleaseCollectionRequest
func (_e *MilvusServiceServer_Expecter) ReleaseCollection(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ReleaseCollection_Call {
	return &MilvusServiceServer_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection", _a0, _a1)}
}

func (_c *MilvusServiceServer_ReleaseCollection_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ReleaseCollectionRequest)) *MilvusServiceServer_ReleaseCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ReleaseCollectionRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ReleaseCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_ReleaseCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ReleaseCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.ReleaseCollectionRequest) (*commonpb.Status, error)) *MilvusServiceServer_ReleaseCollection_Call {
	_c.Call.Return(run)
	return _c
}

// ReleasePartitions provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ReleasePartitions(_a0 context.Context, _a1 *milvuspb.ReleasePartitionsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ReleasePartitions")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ReleasePartitionsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ReleasePartitionsRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ReleasePartitionsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ReleasePartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleasePartitions'
type MilvusServiceServer_ReleasePartitions_Call struct {
	*mock.Call
}

// ReleasePartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ReleasePartitionsRequest
func (_e *MilvusServiceServer_Expecter) ReleasePartitions(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ReleasePartitions_Call {
	return &MilvusServiceServer_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions", _a0, _a1)}
}

func (_c *MilvusServiceServer_ReleasePartitions_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ReleasePartitionsRequest)) *MilvusServiceServer_ReleasePartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ReleasePartitionsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ReleasePartitions_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_ReleasePartitions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ReleasePartitions_Call) RunAndReturn(run func(context.Context, *milvuspb.ReleasePartitionsRequest) (*commonpb.Status, error)) *MilvusServiceServer_ReleasePartitions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveFileResource provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RemoveFileResource(_a0 context.Context, _a1 *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RemoveFileResource")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RemoveFileResourceRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RemoveFileResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveFileResource'
type MilvusServiceServer_RemoveFileResource_Call struct {
	*mock.Call
}

// RemoveFileResource is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RemoveFileResourceRequest
func (_e *MilvusServiceServer_Expecter) RemoveFileResource(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RemoveFileResource_Call {
	return &MilvusServiceServer_RemoveFileResource_Call{Call: _e.mock.On("RemoveFileResource", _a0, _a1)}
}

func (_c *MilvusServiceServer_RemoveFileResource_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RemoveFileResourceRequest)) *MilvusServiceServer_RemoveFileResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RemoveFileResourceRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RemoveFileResource_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_RemoveFileResource_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RemoveFileResource_Call) RunAndReturn(run func(context.Context, *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error)) *MilvusServiceServer_RemoveFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// RenameCollection provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RenameCollection(_a0 context.Context, _a1 *milvuspb.RenameCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RenameCollection")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RenameCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RenameCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameCollection'
type MilvusServiceServer_RenameCollection_Call struct {
	*mock.Call
}

// RenameCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RenameCollectionRequest
func (_e *MilvusServiceServer_Expecter) RenameCollection(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RenameCollection_Call {
	return &MilvusServiceServer_RenameCollection_Call{Call: _e.mock.On("RenameCollection", _a0, _a1)}
}

func (_c *MilvusServiceServer_RenameCollection_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RenameCollectionRequest)) *MilvusServiceServer_RenameCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RenameCollectionRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RenameCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_RenameCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RenameCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.RenameCollectionRequest) (*commonpb.Status, error)) *MilvusServiceServer_RenameCollection_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateMessage provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ReplicateMessage(_a0 context.Context, _a1 *milvuspb.ReplicateMessageRequest) (*milvuspb.ReplicateMessageResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateMessage")
	}

	var r0 *milvuspb.ReplicateMessageResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ReplicateMessageRequest) (*milvuspb.ReplicateMessageResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ReplicateMessageRequest) *milvuspb.ReplicateMessageResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ReplicateMessageResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ReplicateMessageRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ReplicateMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateMessage'
type MilvusServiceServer_ReplicateMessage_Call struct {
	*mock.Call
}

// ReplicateMessage is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ReplicateMessageRequest
func (_e *MilvusServiceServer_Expecter) ReplicateMessage(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ReplicateMessage_Call {
	return &MilvusServiceServer_ReplicateMessage_Call{Call: _e.mock.On("ReplicateMessage", _a0, _a1)}
}

func (_c *MilvusServiceServer_ReplicateMessage_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ReplicateMessageRequest)) *MilvusServiceServer_ReplicateMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ReplicateMessageRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ReplicateMessage_Call) Return(_a0 *milvuspb.ReplicateMessageResponse, _a1 error) *MilvusServiceServer_ReplicateMessage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ReplicateMessage_Call) RunAndReturn(run func(context.Context, *milvuspb.ReplicateMessageRequest) (*milvuspb.ReplicateMessageResponse, error)) *MilvusServiceServer_ReplicateMessage_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreExternalSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RestoreExternalSnapshot(_a0 context.Context, _a1 *milvuspb.RestoreExternalSnapshotRequest) (*milvuspb.RestoreExternalSnapshotResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RestoreExternalSnapshot")
	}

	var r0 *milvuspb.RestoreExternalSnapshotResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreExternalSnapshotRequest) (*milvuspb.RestoreExternalSnapshotResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreExternalSnapshotRequest) *milvuspb.RestoreExternalSnapshotResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.RestoreExternalSnapshotResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RestoreExternalSnapshotRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RestoreExternalSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreExternalSnapshot'
type MilvusServiceServer_RestoreExternalSnapshot_Call struct {
	*mock.Call
}

// RestoreExternalSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RestoreExternalSnapshotRequest
func (_e *MilvusServiceServer_Expecter) RestoreExternalSnapshot(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RestoreExternalSnapshot_Call {
	return &MilvusServiceServer_RestoreExternalSnapshot_Call{Call: _e.mock.On("RestoreExternalSnapshot", _a0, _a1)}
}

func (_c *MilvusServiceServer_RestoreExternalSnapshot_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RestoreExternalSnapshotRequest)) *MilvusServiceServer_RestoreExternalSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RestoreExternalSnapshotRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RestoreExternalSnapshot_Call) Return(_a0 *milvuspb.RestoreExternalSnapshotResponse, _a1 error) *MilvusServiceServer_RestoreExternalSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RestoreExternalSnapshot_Call) RunAndReturn(run func(context.Context, *milvuspb.RestoreExternalSnapshotRequest) (*milvuspb.RestoreExternalSnapshotResponse, error)) *MilvusServiceServer_RestoreExternalSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreRBAC provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RestoreRBAC(_a0 context.Context, _a1 *milvuspb.RestoreRBACMetaRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RestoreRBAC")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreRBACMetaRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreRBACMetaRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RestoreRBACMetaRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RestoreRBAC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreRBAC'
type MilvusServiceServer_RestoreRBAC_Call struct {
	*mock.Call
}

// RestoreRBAC is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RestoreRBACMetaRequest
func (_e *MilvusServiceServer_Expecter) RestoreRBAC(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RestoreRBAC_Call {
	return &MilvusServiceServer_RestoreRBAC_Call{Call: _e.mock.On("RestoreRBAC", _a0, _a1)}
}

func (_c *MilvusServiceServer_RestoreRBAC_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RestoreRBACMetaRequest)) *MilvusServiceServer_RestoreRBAC_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RestoreRBACMetaRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RestoreRBAC_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_RestoreRBAC_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RestoreRBAC_Call) RunAndReturn(run func(context.Context, *milvuspb.RestoreRBACMetaRequest) (*commonpb.Status, error)) *MilvusServiceServer_RestoreRBAC_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreSnapshot provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RestoreSnapshot(_a0 context.Context, _a1 *milvuspb.RestoreSnapshotRequest) (*milvuspb.RestoreSnapshotResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RestoreSnapshot")
	}

	var r0 *milvuspb.RestoreSnapshotResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreSnapshotRequest) (*milvuspb.RestoreSnapshotResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RestoreSnapshotRequest) *milvuspb.RestoreSnapshotResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.RestoreSnapshotResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RestoreSnapshotRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RestoreSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreSnapshot'
type MilvusServiceServer_RestoreSnapshot_Call struct {
	*mock.Call
}

// RestoreSnapshot is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RestoreSnapshotRequest
func (_e *MilvusServiceServer_Expecter) RestoreSnapshot(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RestoreSnapshot_Call {
	return &MilvusServiceServer_RestoreSnapshot_Call{Call: _e.mock.On("RestoreSnapshot", _a0, _a1)}
}

func (_c *MilvusServiceServer_RestoreSnapshot_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RestoreSnapshotRequest)) *MilvusServiceServer_RestoreSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RestoreSnapshotRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RestoreSnapshot_Call) Return(_a0 *milvuspb.RestoreSnapshotResponse, _a1 error) *MilvusServiceServer_RestoreSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RestoreSnapshot_Call) RunAndReturn(run func(context.Context, *milvuspb.RestoreSnapshotRequest) (*milvuspb.RestoreSnapshotResponse, error)) *MilvusServiceServer_RestoreSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// RunAnalyzer provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) RunAnalyzer(_a0 context.Context, _a1 *milvuspb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for RunAnalyzer")
	}

	var r0 *milvuspb.RunAnalyzerResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RunAnalyzerRequest) *milvuspb.RunAnalyzerResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.RunAnalyzerResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RunAnalyzerRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_RunAnalyzer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunAnalyzer'
type MilvusServiceServer_RunAnalyzer_Call struct {
	*mock.Call
}

// RunAnalyzer is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.RunAnalyzerRequest
func (_e *MilvusServiceServer_Expecter) RunAnalyzer(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_RunAnalyzer_Call {
	return &MilvusServiceServer_RunAnalyzer_Call{Call: _e.mock.On("RunAnalyzer", _a0, _a1)}
}

func (_c *MilvusServiceServer_RunAnalyzer_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RunAnalyzerRequest)) *MilvusServiceServer_RunAnalyzer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.RunAnalyzerRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_RunAnalyzer_Call) Return(_a0 *milvuspb.RunAnalyzerResponse, _a1 error) *MilvusServiceServer_RunAnalyzer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_RunAnalyzer_Call) RunAndReturn(run func(context.Context, *milvuspb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error)) *MilvusServiceServer_RunAnalyzer_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Search(_a0 context.Context, _a1 *milvuspb.SearchRequest) (*milvuspb.SearchResults, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for Search")
	}

	var r0 *milvuspb.SearchResults
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SearchRequest) (*milvuspb.SearchResults, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SearchRequest) *milvuspb.SearchResults); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SearchResults)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SearchRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
type MilvusServiceServer_Search_Call struct {
	*mock.Call
}

// Search is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SearchRequest
func (_e *MilvusServiceServer_Expecter) Search(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Search_Call {
	return &MilvusServiceServer_Search_Call{Call: _e.mock.On("Search", _a0, _a1)}
}

func (_c *MilvusServiceServer_Search_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.SearchRequest)) *MilvusServiceServer_Search_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.SearchRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_Search_Call) Return(_a0 *milvuspb.SearchResults, _a1 error) *MilvusServiceServer_Search_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_Search_Call) RunAndReturn(run func(context.Context, *milvuspb.SearchRequest) (*milvuspb.SearchResults, error)) *MilvusServiceServer_Search_Call {
	_c.Call.Return(run)
	return _c
}

// SelectGrant provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) SelectGrant(_a0 context.Context, _a1 *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for SelectGrant")
	}

	var r0 *milvuspb.SelectGrantResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectGrantRequest) *milvuspb.SelectGrantResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SelectGrantResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectGrantRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_SelectGrant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectGrant'
type MilvusServiceServer_SelectGrant_Call struct {
	*mock.Call
}

// SelectGrant is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SelectGrantRequest
func (_e *MilvusServiceServer_Expecter) SelectGrant(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_SelectGrant_Call {
	return &MilvusServiceServer_SelectGrant_Call{Call: _e.mock.On("SelectGrant", _a0, _a1)}
}

func (_c *MilvusServiceServer_SelectGrant_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.SelectGrantRequest)) *MilvusServiceServer_SelectGrant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.SelectGrantRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_SelectGrant_Call) Return(_a0 *milvuspb.SelectGrantResponse, _a1 error) *MilvusServiceServer_SelectGrant_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_SelectGrant_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)) *MilvusServiceServer_SelectGrant_Call {
	_c.Call.Return(run)
	return _c
}

// SelectRole provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) SelectRole(_a0 context.Context, _a1 *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for SelectRole")
	}

	var r0 *milvuspb.SelectRoleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectRoleRequest) *milvuspb.SelectRoleResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SelectRoleResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectRoleRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_SelectRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectRole'
type MilvusServiceServer_SelectRole_Call struct {
	*mock.Call
}

// SelectRole is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SelectRoleRequest
func (_e *MilvusServiceServer_Expecter) SelectRole(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_SelectRole_Call {
	return &MilvusServiceServer_SelectRole_Call{Call: _e.mock.On("SelectRole", _a0, _a1)}
}

func (_c *MilvusServiceServer_SelectRole_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.SelectRoleRequest)) *MilvusServiceServer_SelectRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.SelectRoleRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_SelectRole_Call) Return(_a0 *milvuspb.SelectRoleResponse, _a1 error) *MilvusServiceServer_SelectRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_SelectRole_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error)) *MilvusServiceServer_SelectRole_Call {
	_c.Call.Return(run)
	return _c
}

// SelectUser provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) SelectUser(_a0 context.Context, _a1 *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for SelectUser")
	}

	var r0 *milvuspb.SelectUserResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectUserRequest) *milvuspb.SelectUserResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.SelectUserResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectUserRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_SelectUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectUser'
type MilvusServiceServer_SelectUser_Call struct {
	*mock.Call
}

// SelectUser is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.SelectUserRequest
func (_e *MilvusServiceServer_Expecter) SelectUser(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_SelectUser_Call {
	return &MilvusServiceServer_SelectUser_Call{Call: _e.mock.On("SelectUser", _a0, _a1)}
}

func (_c *MilvusServiceServer_SelectUser_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.SelectUserRequest)) *MilvusServiceServer_SelectUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.SelectUserRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_SelectUser_Call) Return(_a0 *milvuspb.SelectUserResponse, _a1 error) *MilvusServiceServer_SelectUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_SelectUser_Call) RunAndReturn(run func(context.Context, *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error)) *MilvusServiceServer_SelectUser_Call {
	_c.Call.Return(run)
	return _c
}

// ShowCollections provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ShowCollections(_a0 context.Context, _a1 *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ShowCollections")
	}

	var r0 *milvuspb.ShowCollectionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowCollectionsRequest) *milvuspb.ShowCollectionsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ShowCollectionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowCollectionsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ShowCollections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowCollections'
type MilvusServiceServer_ShowCollections_Call struct {
	*mock.Call
}

// ShowCollections is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ShowCollectionsRequest
func (_e *MilvusServiceServer_Expecter) ShowCollections(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ShowCollections_Call {
	return &MilvusServiceServer_ShowCollections_Call{Call: _e.mock.On("ShowCollections", _a0, _a1)}
}

func (_c *MilvusServiceServer_ShowCollections_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ShowCollectionsRequest)) *MilvusServiceServer_ShowCollections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ShowCollectionsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ShowCollections_Call) Return(_a0 *milvuspb.ShowCollectionsResponse, _a1 error) *MilvusServiceServer_ShowCollections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ShowCollections_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error)) *MilvusServiceServer_ShowCollections_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPartitions provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) ShowPartitions(_a0 context.Context, _a1 *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for ShowPartitions")
	}

	var r0 *milvuspb.ShowPartitionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest) *milvuspb.ShowPartitionsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ShowPartitionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowPartitionsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_ShowPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPartitions'
type MilvusServiceServer_ShowPartitions_Call struct {
	*mock.Call
}

// ShowPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.ShowPartitionsRequest
func (_e *MilvusServiceServer_Expecter) ShowPartitions(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_ShowPartitions_Call {
	return &MilvusServiceServer_ShowPartitions_Call{Call: _e.mock.On("ShowPartitions", _a0, _a1)}
}

func (_c *MilvusServiceServer_ShowPartitions_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ShowPartitionsRequest)) *MilvusServiceServer_ShowPartitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.ShowPartitionsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_ShowPartitions_Call) Return(_a0 *milvuspb.ShowPartitionsResponse, _a1 error) *MilvusServiceServer_ShowPartitions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_ShowPartitions_Call) RunAndReturn(run func(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)) *MilvusServiceServer_ShowPartitions_Call {
	_c.Call.Return(run)
	return _c
}

// TransferNode provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) TransferNode(_a0 context.Context, _a1 *milvuspb.TransferNodeRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for TransferNode")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.TransferNodeRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_TransferNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferNode'
type MilvusServiceServer_TransferNode_Call struct {
	*mock.Call
}

// TransferNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.TransferNodeRequest
func (_e *MilvusServiceServer_Expecter) TransferNode(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_TransferNode_Call {
	return &MilvusServiceServer_TransferNode_Call{Call: _e.mock.On("TransferNode", _a0, _a1)}
}

func (_c *MilvusServiceServer_TransferNode_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.TransferNodeRequest)) *MilvusServiceServer_TransferNode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.TransferNodeRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_TransferNode_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_TransferNode_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_TransferNode_Call) RunAndReturn(run func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)) *MilvusServiceServer_TransferNode_Call {
	_c.Call.Return(run)
	return _c
}

// TransferReplica provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) TransferReplica(_a0 context.Context, _a1 *milvuspb.TransferReplicaRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for TransferReplica")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferReplicaRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferReplicaRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.TransferReplicaRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_TransferReplica_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferReplica'
type MilvusServiceServer_TransferReplica_Call struct {
	*mock.Call
}

// TransferReplica is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.TransferReplicaRequest
func (_e *MilvusServiceServer_Expecter) TransferReplica(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_TransferReplica_Call {
	return &MilvusServiceServer_TransferReplica_Call{Call: _e.mock.On("TransferReplica", _a0, _a1)}
}

func (_c *MilvusServiceServer_TransferReplica_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.TransferReplicaRequest)) *MilvusServiceServer_TransferReplica_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.TransferReplicaRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_TransferReplica_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_TransferReplica_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_TransferReplica_Call) RunAndReturn(run func(context.Context, *milvuspb.TransferReplicaRequest) (*commonpb.Status, error)) *MilvusServiceServer_TransferReplica_Call {
	_c.Call.Return(run)
	return _c
}

// TruncateCollection provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) TruncateCollection(_a0 context.Context, _a1 *milvuspb.TruncateCollectionRequest) (*milvuspb.TruncateCollectionResponse, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for TruncateCollection")
	}

	var r0 *milvuspb.TruncateCollectionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TruncateCollectionRequest) (*milvuspb.TruncateCollectionResponse, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TruncateCollectionRequest) *milvuspb.TruncateCollectionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.TruncateCollectionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.TruncateCollectionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_TruncateCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TruncateCollection'
type MilvusServiceServer_TruncateCollection_Call struct {
	*mock.Call
}

// TruncateCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.TruncateCollectionRequest
func (_e *MilvusServiceServer_Expecter) TruncateCollection(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_TruncateCollection_Call {
	return &MilvusServiceServer_TruncateCollection_Call{Call: _e.mock.On("TruncateCollection", _a0, _a1)}
}

func (_c *MilvusServiceServer_TruncateCollection_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.TruncateCollectionRequest)) *MilvusServiceServer_TruncateCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.TruncateCollectionRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_TruncateCollection_Call) Return(_a0 *milvuspb.TruncateCollectionResponse, _a1 error) *MilvusServiceServer_TruncateCollection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_TruncateCollection_Call) RunAndReturn(run func(context.Context, *milvuspb.TruncateCollectionRequest) (*milvuspb.TruncateCollectionResponse, error)) *MilvusServiceServer_TruncateCollection_Call {
	_c.Call.Return(run)
	return _c
}

// UnpinSnapshotData provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) UnpinSnapshotData(_a0 context.Context, _a1 *milvuspb.UnpinSnapshotDataRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for UnpinSnapshotData")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UnpinSnapshotDataRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UnpinSnapshotDataRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.UnpinSnapshotDataRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_UnpinSnapshotData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnpinSnapshotData'
type MilvusServiceServer_UnpinSnapshotData_Call struct {
	*mock.Call
}

// UnpinSnapshotData is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.UnpinSnapshotDataRequest
func (_e *MilvusServiceServer_Expecter) UnpinSnapshotData(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_UnpinSnapshotData_Call {
	return &MilvusServiceServer_UnpinSnapshotData_Call{Call: _e.mock.On("UnpinSnapshotData", _a0, _a1)}
}

func (_c *MilvusServiceServer_UnpinSnapshotData_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.UnpinSnapshotDataRequest)) *MilvusServiceServer_UnpinSnapshotData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.UnpinSnapshotDataRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_UnpinSnapshotData_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_UnpinSnapshotData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_UnpinSnapshotData_Call) RunAndReturn(run func(context.Context, *milvuspb.UnpinSnapshotDataRequest) (*commonpb.Status, error)) *MilvusServiceServer_UnpinSnapshotData_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateCredential provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) UpdateCredential(_a0 context.Context, _a1 *milvuspb.UpdateCredentialRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for UpdateCredential")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpdateCredentialRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpdateCredentialRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.UpdateCredentialRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_UpdateCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCredential'
type MilvusServiceServer_UpdateCredential_Call struct {
	*mock.Call
}

// UpdateCredential is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.UpdateCredentialRequest
func (_e *MilvusServiceServer_Expecter) UpdateCredential(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_UpdateCredential_Call {
	return &MilvusServiceServer_UpdateCredential_Call{Call: _e.mock.On("UpdateCredential", _a0, _a1)}
}

func (_c *MilvusServiceServer_UpdateCredential_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.UpdateCredentialRequest)) *MilvusServiceServer_UpdateCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.UpdateCredentialRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_UpdateCredential_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_UpdateCredential_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_UpdateCredential_Call) RunAndReturn(run func(context.Context, *milvuspb.UpdateCredentialRequest) (*commonpb.Status, error)) *MilvusServiceServer_UpdateCredential_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReplicateConfiguration provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) UpdateReplicateConfiguration(_a0 context.Context, _a1 *milvuspb.UpdateReplicateConfigurationRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for UpdateReplicateConfiguration")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpdateReplicateConfigurationRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpdateReplicateConfigurationRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.UpdateReplicateConfigurationRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_UpdateReplicateConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReplicateConfiguration'
type MilvusServiceServer_UpdateReplicateConfiguration_Call struct {
	*mock.Call
}

// UpdateReplicateConfiguration is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.UpdateReplicateConfigurationRequest
func (_e *MilvusServiceServer_Expecter) UpdateReplicateConfiguration(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_UpdateReplicateConfiguration_Call {
	return &MilvusServiceServer_UpdateReplicateConfiguration_Call{Call: _e.mock.On("UpdateReplicateConfiguration", _a0, _a1)}
}

func (_c *MilvusServiceServer_UpdateReplicateConfiguration_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.UpdateReplicateConfigurationRequest)) *MilvusServiceServer_UpdateReplicateConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.UpdateReplicateConfigurationRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_UpdateReplicateConfiguration_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_UpdateReplicateConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_UpdateReplicateConfiguration_Call) RunAndReturn(run func(context.Context, *milvuspb.UpdateReplicateConfigurationRequest) (*commonpb.Status, error)) *MilvusServiceServer_UpdateReplicateConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateResourceGroups provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) UpdateResourceGroups(_a0 context.Context, _a1 *milvuspb.UpdateResourceGroupsRequest) (*commonpb.Status, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for UpdateResourceGroups")
	}

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpdateResourceGroupsRequest) (*commonpb.Status, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpdateResourceGroupsRequest) *commonpb.Status); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.Status)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.UpdateResourceGroupsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_UpdateResourceGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateResourceGroups'
type MilvusServiceServer_UpdateResourceGroups_Call struct {
	*mock.Call
}

// UpdateResourceGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.UpdateResourceGroupsRequest
func (_e *MilvusServiceServer_Expecter) UpdateResourceGroups(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_UpdateResourceGroups_Call {
	return &MilvusServiceServer_UpdateResourceGroups_Call{Call: _e.mock.On("UpdateResourceGroups", _a0, _a1)}
}

func (_c *MilvusServiceServer_UpdateResourceGroups_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.UpdateResourceGroupsRequest)) *MilvusServiceServer_UpdateResourceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.UpdateResourceGroupsRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_UpdateResourceGroups_Call) Return(_a0 *commonpb.Status, _a1 error) *MilvusServiceServer_UpdateResourceGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_UpdateResourceGroups_Call) RunAndReturn(run func(context.Context, *milvuspb.UpdateResourceGroupsRequest) (*commonpb.Status, error)) *MilvusServiceServer_UpdateResourceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// Upsert provides a mock function with given fields: _a0, _a1
func (_m *MilvusServiceServer) Upsert(_a0 context.Context, _a1 *milvuspb.UpsertRequest) (*milvuspb.MutationResult, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for Upsert")
	}

	var r0 *milvuspb.MutationResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpsertRequest) (*milvuspb.MutationResult, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.UpsertRequest) *milvuspb.MutationResult); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.MutationResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.UpsertRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MilvusServiceServer_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'
type MilvusServiceServer_Upsert_Call struct {
	*mock.Call
}

// Upsert is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.UpsertRequest
func (_e *MilvusServiceServer_Expecter) Upsert(_a0 interface{}, _a1 interface{}) *MilvusServiceServer_Upsert_Call {
	return &MilvusServiceServer_Upsert_Call{Call: _e.mock.On("Upsert", _a0, _a1)}
}

func (_c *MilvusServiceServer_Upsert_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.UpsertRequest)) *MilvusServiceServer_Upsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.UpsertRequest))
	})
	return _c
}

func (_c *MilvusServiceServer_Upsert_Call) Return(_a0 *milvuspb.MutationResult, _a1 error) *MilvusServiceServer_Upsert_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MilvusServiceServer_Upsert_Call) RunAndReturn(run func(context.Context, *milvuspb.UpsertRequest) (*milvuspb.MutationResult, error)) *MilvusServiceServer_Upsert_Call {
	_c.Call.Return(run)
	return _c
}

// NewMilvusServiceServer creates a new instance of MilvusServiceServer. 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 NewMilvusServiceServer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MilvusServiceServer {
	mock := &MilvusServiceServer{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
