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

package mocks

import (
	context "context"

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

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

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

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

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

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

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

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

type MockQueryCoord_Expecter struct {
	mock *mock.Mock
}

func (_m *MockQueryCoord) EXPECT() *MockQueryCoord_Expecter {
	return &MockQueryCoord_Expecter{mock: &_m.Mock}
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// ClearReadTaskQueue provides a mock function with given fields: _a0, _a1
func (_m *MockQueryCoord) ClearReadTaskQueue(_a0 context.Context, _a1 *internalpb.ClearReadTaskQueueRequest) (*internalpb.ClearReadTaskQueueResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ClearReadTaskQueue is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *internalpb.ClearReadTaskQueueRequest
func (_e *MockQueryCoord_Expecter) ClearReadTaskQueue(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ClearReadTaskQueue_Call {
	return &MockQueryCoord_ClearReadTaskQueue_Call{Call: _e.mock.On("ClearReadTaskQueue", _a0, _a1)}
}

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

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

func (_c *MockQueryCoord_ClearReadTaskQueue_Call) RunAndReturn(run func(context.Context, *internalpb.ClearReadTaskQueueRequest) (*internalpb.ClearReadTaskQueueResponse, error)) *MockQueryCoord_ClearReadTaskQueue_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// LoadBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.LoadBalanceRequest
func (_e *MockQueryCoord_Expecter) LoadBalance(_a0 interface{}, _a1 interface{}) *MockQueryCoord_LoadBalance_Call {
	return &MockQueryCoord_LoadBalance_Call{Call: _e.mock.On("LoadBalance", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// LoadCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.LoadCollectionRequest
func (_e *MockQueryCoord_Expecter) LoadCollection(_a0 interface{}, _a1 interface{}) *MockQueryCoord_LoadCollection_Call {
	return &MockQueryCoord_LoadCollection_Call{Call: _e.mock.On("LoadCollection", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// LoadPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.LoadPartitionsRequest
func (_e *MockQueryCoord_Expecter) LoadPartitions(_a0 interface{}, _a1 interface{}) *MockQueryCoord_LoadPartitions_Call {
	return &MockQueryCoord_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions", _a0, _a1)}
}

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// ReleaseCollection is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ReleaseCollectionRequest
func (_e *MockQueryCoord_Expecter) ReleaseCollection(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ReleaseCollection_Call {
	return &MockQueryCoord_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// ReleasePartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ReleasePartitionsRequest
func (_e *MockQueryCoord_Expecter) ReleasePartitions(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ReleasePartitions_Call {
	return &MockQueryCoord_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// ResumeBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ResumeBalanceRequest
func (_e *MockQueryCoord_Expecter) ResumeBalance(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ResumeBalance_Call {
	return &MockQueryCoord_ResumeBalance_Call{Call: _e.mock.On("ResumeBalance", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// ResumeNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ResumeNodeRequest
func (_e *MockQueryCoord_Expecter) ResumeNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ResumeNode_Call {
	return &MockQueryCoord_ResumeNode_Call{Call: _e.mock.On("ResumeNode", _a0, _a1)}
}

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

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

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

// RunAnalyzer provides a mock function with given fields: _a0, _a1
func (_m *MockQueryCoord) RunAnalyzer(_a0 context.Context, _a1 *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// RunAnalyzer is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.RunAnalyzerRequest
func (_e *MockQueryCoord_Expecter) RunAnalyzer(_a0 interface{}, _a1 interface{}) *MockQueryCoord_RunAnalyzer_Call {
	return &MockQueryCoord_RunAnalyzer_Call{Call: _e.mock.On("RunAnalyzer", _a0, _a1)}
}

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

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

func (_c *MockQueryCoord_RunAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error)) *MockQueryCoord_RunAnalyzer_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

// ShowLoadCollections provides a mock function with given fields: _a0, _a1
func (_m *MockQueryCoord) ShowLoadCollections(_a0 context.Context, _a1 *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowLoadCollections is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ShowCollectionsRequest
func (_e *MockQueryCoord_Expecter) ShowLoadCollections(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ShowLoadCollections_Call {
	return &MockQueryCoord_ShowLoadCollections_Call{Call: _e.mock.On("ShowLoadCollections", _a0, _a1)}
}

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

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

func (_c *MockQueryCoord_ShowLoadCollections_Call) RunAndReturn(run func(context.Context, *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error)) *MockQueryCoord_ShowLoadCollections_Call {
	_c.Call.Return(run)
	return _c
}

// ShowLoadPartitions provides a mock function with given fields: _a0, _a1
func (_m *MockQueryCoord) ShowLoadPartitions(_a0 context.Context, _a1 *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ShowLoadPartitions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ShowPartitionsRequest
func (_e *MockQueryCoord_Expecter) ShowLoadPartitions(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ShowLoadPartitions_Call {
	return &MockQueryCoord_ShowLoadPartitions_Call{Call: _e.mock.On("ShowLoadPartitions", _a0, _a1)}
}

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

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

func (_c *MockQueryCoord_ShowLoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error)) *MockQueryCoord_ShowLoadPartitions_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

// SuspendBalance is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.SuspendBalanceRequest
func (_e *MockQueryCoord_Expecter) SuspendBalance(_a0 interface{}, _a1 interface{}) *MockQueryCoord_SuspendBalance_Call {
	return &MockQueryCoord_SuspendBalance_Call{Call: _e.mock.On("SuspendBalance", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// SuspendNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.SuspendNodeRequest
func (_e *MockQueryCoord_Expecter) SuspendNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_SuspendNode_Call {
	return &MockQueryCoord_SuspendNode_Call{Call: _e.mock.On("SuspendNode", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// SyncNewCreatedPartition is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.SyncNewCreatedPartitionRequest
func (_e *MockQueryCoord_Expecter) SyncNewCreatedPartition(_a0 interface{}, _a1 interface{}) *MockQueryCoord_SyncNewCreatedPartition_Call {
	return &MockQueryCoord_SyncNewCreatedPartition_Call{Call: _e.mock.On("SyncNewCreatedPartition", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// TransferChannel is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.TransferChannelRequest
func (_e *MockQueryCoord_Expecter) TransferChannel(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferChannel_Call {
	return &MockQueryCoord_TransferChannel_Call{Call: _e.mock.On("TransferChannel", _a0, _a1)}
}

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

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

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

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

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

// TransferNode is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *milvuspb.TransferNodeRequest
func (_e *MockQueryCoord_Expecter) TransferNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferNode_Call {
	return &MockQueryCoord_TransferNode_Call{Call: _e.mock.On("TransferNode", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// TransferReplica is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.TransferReplicaRequest
func (_e *MockQueryCoord_Expecter) TransferReplica(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferReplica_Call {
	return &MockQueryCoord_TransferReplica_Call{Call: _e.mock.On("TransferReplica", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// TransferSegment is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.TransferSegmentRequest
func (_e *MockQueryCoord_Expecter) TransferSegment(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferSegment_Call {
	return &MockQueryCoord_TransferSegment_Call{Call: _e.mock.On("TransferSegment", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// UpdateLoadConfig is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.UpdateLoadConfigRequest
func (_e *MockQueryCoord_Expecter) UpdateLoadConfig(_a0 interface{}, _a1 interface{}) *MockQueryCoord_UpdateLoadConfig_Call {
	return &MockQueryCoord_UpdateLoadConfig_Call{Call: _e.mock.On("UpdateLoadConfig", _a0, _a1)}
}

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

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

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

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

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

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

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

	return r0, r1
}

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

// UpdateResourceGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.UpdateResourceGroupsRequest
func (_e *MockQueryCoord_Expecter) UpdateResourceGroups(_a0 interface{}, _a1 interface{}) *MockQueryCoord_UpdateResourceGroups_Call {
	return &MockQueryCoord_UpdateResourceGroups_Call{Call: _e.mock.On("UpdateResourceGroups", _a0, _a1)}
}

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

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

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

// UpdateStateCode provides a mock function with given fields: stateCode
func (_m *MockQueryCoord) UpdateStateCode(stateCode commonpb.StateCode) {
	_m.Called(stateCode)
}

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

// UpdateStateCode is a helper method to define mock.On call
//   - stateCode commonpb.StateCode
func (_e *MockQueryCoord_Expecter) UpdateStateCode(stateCode interface{}) *MockQueryCoord_UpdateStateCode_Call {
	return &MockQueryCoord_UpdateStateCode_Call{Call: _e.mock.On("UpdateStateCode", stateCode)}
}

func (_c *MockQueryCoord_UpdateStateCode_Call) Run(run func(stateCode commonpb.StateCode)) *MockQueryCoord_UpdateStateCode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(commonpb.StateCode))
	})
	return _c
}

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

func (_c *MockQueryCoord_UpdateStateCode_Call) RunAndReturn(run func(commonpb.StateCode)) *MockQueryCoord_UpdateStateCode_Call {
	_c.Run(run)
	return _c
}

// ValidateAnalyzer provides a mock function with given fields: _a0, _a1
func (_m *MockQueryCoord) ValidateAnalyzer(_a0 context.Context, _a1 *querypb.ValidateAnalyzerRequest) (*querypb.ValidateAnalyzerResponse, error) {
	ret := _m.Called(_a0, _a1)

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

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

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

	return r0, r1
}

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

// ValidateAnalyzer is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *querypb.ValidateAnalyzerRequest
func (_e *MockQueryCoord_Expecter) ValidateAnalyzer(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ValidateAnalyzer_Call {
	return &MockQueryCoord_ValidateAnalyzer_Call{Call: _e.mock.On("ValidateAnalyzer", _a0, _a1)}
}

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

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

func (_c *MockQueryCoord_ValidateAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.ValidateAnalyzerRequest) (*querypb.ValidateAnalyzerResponse, error)) *MockQueryCoord_ValidateAnalyzer_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
