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

package mocks

import (
	context "context"

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

	internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"

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

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

	querypb "github.com/milvus-io/milvus/internal/proto/querypb"

	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}
}

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

	var r0 *milvuspb.CheckHealthResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *milvuspb.CheckHealthRequest
func (_e *MockQueryCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *MockQueryCoord_CheckHealth_Call {
	return &MockQueryCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)}
}

func (_c *MockQueryCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *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
}

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *milvuspb.CreateResourceGroupRequest
func (_e *MockQueryCoord_Expecter) CreateResourceGroup(ctx interface{}, req interface{}) *MockQueryCoord_CreateResourceGroup_Call {
	return &MockQueryCoord_CreateResourceGroup_Call{Call: _e.mock.On("CreateResourceGroup", ctx, req)}
}

func (_c *MockQueryCoord_CreateResourceGroup_Call) Run(run func(ctx context.Context, req *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
}

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

	var r0 *querypb.DescribeResourceGroupResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.DescribeResourceGroupRequest) (*querypb.DescribeResourceGroupResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.DescribeResourceGroupRequest) *querypb.DescribeResourceGroupResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.DescribeResourceGroupRequest
func (_e *MockQueryCoord_Expecter) DescribeResourceGroup(ctx interface{}, req interface{}) *MockQueryCoord_DescribeResourceGroup_Call {
	return &MockQueryCoord_DescribeResourceGroup_Call{Call: _e.mock.On("DescribeResourceGroup", ctx, req)}
}

func (_c *MockQueryCoord_DescribeResourceGroup_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) DropResourceGroup(ctx context.Context, req *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *milvuspb.DropResourceGroupRequest
func (_e *MockQueryCoord_Expecter) DropResourceGroup(ctx interface{}, req interface{}) *MockQueryCoord_DropResourceGroup_Call {
	return &MockQueryCoord_DropResourceGroup_Call{Call: _e.mock.On("DropResourceGroup", ctx, req)}
}

func (_c *MockQueryCoord_DropResourceGroup_Call) Run(run func(ctx context.Context, req *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
}

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetComponentStates is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQueryCoord_Expecter) GetComponentStates(ctx interface{}) *MockQueryCoord_GetComponentStates_Call {
	return &MockQueryCoord_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx)}
}

func (_c *MockQueryCoord_GetComponentStates_Call) Run(run func(ctx context.Context)) *MockQueryCoord_GetComponentStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

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

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

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

	return r0, r1
}

// 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
//   - ctx context.Context
//   - req *milvuspb.GetMetricsRequest
func (_e *MockQueryCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *MockQueryCoord_GetMetrics_Call {
	return &MockQueryCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)}
}

func (_c *MockQueryCoord_GetMetrics_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) GetPartitionStates(ctx context.Context, req *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error) {
	ret := _m.Called(ctx, req)

	var r0 *querypb.GetPartitionStatesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetPartitionStatesRequest) *querypb.GetPartitionStatesResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.GetPartitionStatesRequest
func (_e *MockQueryCoord_Expecter) GetPartitionStates(ctx interface{}, req interface{}) *MockQueryCoord_GetPartitionStates_Call {
	return &MockQueryCoord_GetPartitionStates_Call{Call: _e.mock.On("GetPartitionStates", ctx, req)}
}

func (_c *MockQueryCoord_GetPartitionStates_Call) Run(run func(ctx context.Context, req *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
}

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

	var r0 *milvuspb.GetReplicasResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetReplicasRequest) *milvuspb.GetReplicasResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *milvuspb.GetReplicasRequest
func (_e *MockQueryCoord_Expecter) GetReplicas(ctx interface{}, req interface{}) *MockQueryCoord_GetReplicas_Call {
	return &MockQueryCoord_GetReplicas_Call{Call: _e.mock.On("GetReplicas", ctx, req)}
}

func (_c *MockQueryCoord_GetReplicas_Call) Run(run func(ctx context.Context, req *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
}

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

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

	return r0, r1
}

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

// GetSegmentInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.GetSegmentInfoRequest
func (_e *MockQueryCoord_Expecter) GetSegmentInfo(ctx interface{}, req interface{}) *MockQueryCoord_GetSegmentInfo_Call {
	return &MockQueryCoord_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", ctx, req)}
}

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

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

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

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

	var r0 *querypb.GetShardLeadersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetShardLeadersRequest) *querypb.GetShardLeadersResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.GetShardLeadersRequest
func (_e *MockQueryCoord_Expecter) GetShardLeaders(ctx interface{}, req interface{}) *MockQueryCoord_GetShardLeaders_Call {
	return &MockQueryCoord_GetShardLeaders_Call{Call: _e.mock.On("GetShardLeaders", ctx, req)}
}

func (_c *MockQueryCoord_GetShardLeaders_Call) Run(run func(ctx context.Context, req *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
}

// GetStatisticsChannel provides a mock function with given fields: ctx
func (_m *MockQueryCoord) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
	ret := _m.Called(ctx)

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetStatisticsChannel is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQueryCoord_Expecter) GetStatisticsChannel(ctx interface{}) *MockQueryCoord_GetStatisticsChannel_Call {
	return &MockQueryCoord_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", ctx)}
}

func (_c *MockQueryCoord_GetStatisticsChannel_Call) Run(run func(ctx context.Context)) *MockQueryCoord_GetStatisticsChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// GetTimeTickChannel provides a mock function with given fields: ctx
func (_m *MockQueryCoord) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
	ret := _m.Called(ctx)

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetTimeTickChannel is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQueryCoord_Expecter) GetTimeTickChannel(ctx interface{}) *MockQueryCoord_GetTimeTickChannel_Call {
	return &MockQueryCoord_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", ctx)}
}

func (_c *MockQueryCoord_GetTimeTickChannel_Call) Run(run func(ctx context.Context)) *MockQueryCoord_GetTimeTickChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

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

	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
}

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

	var r0 *milvuspb.ListResourceGroupsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest) *milvuspb.ListResourceGroupsResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *milvuspb.ListResourceGroupsRequest
func (_e *MockQueryCoord_Expecter) ListResourceGroups(ctx interface{}, req interface{}) *MockQueryCoord_ListResourceGroups_Call {
	return &MockQueryCoord_ListResourceGroups_Call{Call: _e.mock.On("ListResourceGroups", ctx, req)}
}

func (_c *MockQueryCoord_ListResourceGroups_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) LoadBalance(ctx context.Context, req *querypb.LoadBalanceRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.LoadBalanceRequest
func (_e *MockQueryCoord_Expecter) LoadBalance(ctx interface{}, req interface{}) *MockQueryCoord_LoadBalance_Call {
	return &MockQueryCoord_LoadBalance_Call{Call: _e.mock.On("LoadBalance", ctx, req)}
}

func (_c *MockQueryCoord_LoadBalance_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) LoadCollection(ctx context.Context, req *querypb.LoadCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.LoadCollectionRequest
func (_e *MockQueryCoord_Expecter) LoadCollection(ctx interface{}, req interface{}) *MockQueryCoord_LoadCollection_Call {
	return &MockQueryCoord_LoadCollection_Call{Call: _e.mock.On("LoadCollection", ctx, req)}
}

func (_c *MockQueryCoord_LoadCollection_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) LoadPartitions(ctx context.Context, req *querypb.LoadPartitionsRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.LoadPartitionsRequest
func (_e *MockQueryCoord_Expecter) LoadPartitions(ctx interface{}, req interface{}) *MockQueryCoord_LoadPartitions_Call {
	return &MockQueryCoord_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions", ctx, req)}
}

func (_c *MockQueryCoord_LoadPartitions_Call) Run(run func(ctx context.Context, req *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 given fields:
func (_m *MockQueryCoord) Register() error {
	ret := _m.Called()

	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: ctx, req
func (_m *MockQueryCoord) ReleaseCollection(ctx context.Context, req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.ReleaseCollectionRequest
func (_e *MockQueryCoord_Expecter) ReleaseCollection(ctx interface{}, req interface{}) *MockQueryCoord_ReleaseCollection_Call {
	return &MockQueryCoord_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection", ctx, req)}
}

func (_c *MockQueryCoord_ReleaseCollection_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) ReleasePartitions(ctx context.Context, req *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.ReleasePartitionsRequest
func (_e *MockQueryCoord_Expecter) ReleasePartitions(ctx interface{}, req interface{}) *MockQueryCoord_ReleasePartitions_Call {
	return &MockQueryCoord_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions", ctx, req)}
}

func (_c *MockQueryCoord_ReleasePartitions_Call) Run(run func(ctx context.Context, req *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
}

// 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.Call.Return(run)
	return _c
}

// SetDataCoord provides a mock function with given fields: dataCoord
func (_m *MockQueryCoord) SetDataCoord(dataCoord types.DataCoord) error {
	ret := _m.Called(dataCoord)

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

	return r0
}

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

// SetDataCoord is a helper method to define mock.On call
//   - dataCoord types.DataCoord
func (_e *MockQueryCoord_Expecter) SetDataCoord(dataCoord interface{}) *MockQueryCoord_SetDataCoord_Call {
	return &MockQueryCoord_SetDataCoord_Call{Call: _e.mock.On("SetDataCoord", dataCoord)}
}

func (_c *MockQueryCoord_SetDataCoord_Call) Run(run func(dataCoord types.DataCoord)) *MockQueryCoord_SetDataCoord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(types.DataCoord))
	})
	return _c
}

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

func (_c *MockQueryCoord_SetDataCoord_Call) RunAndReturn(run func(types.DataCoord) error) *MockQueryCoord_SetDataCoord_Call {
	_c.Call.Return(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.Call.Return(run)
	return _c
}

// SetQueryNodeCreator provides a mock function with given fields: _a0
func (_m *MockQueryCoord) SetQueryNodeCreator(_a0 func(context.Context, string) (types.QueryNode, 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)(types.QueryNode , 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) (types.QueryNode, error))) *MockQueryCoord_SetQueryNodeCreator_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, string) (types.QueryNode, 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) (types.QueryNode, error))) *MockQueryCoord_SetQueryNodeCreator_Call {
	_c.Call.Return(run)
	return _c
}

// SetRootCoord provides a mock function with given fields: rootCoord
func (_m *MockQueryCoord) SetRootCoord(rootCoord types.RootCoord) error {
	ret := _m.Called(rootCoord)

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

	return r0
}

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

// SetRootCoord is a helper method to define mock.On call
//   - rootCoord types.RootCoord
func (_e *MockQueryCoord_Expecter) SetRootCoord(rootCoord interface{}) *MockQueryCoord_SetRootCoord_Call {
	return &MockQueryCoord_SetRootCoord_Call{Call: _e.mock.On("SetRootCoord", rootCoord)}
}

func (_c *MockQueryCoord_SetRootCoord_Call) Run(run func(rootCoord types.RootCoord)) *MockQueryCoord_SetRootCoord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(types.RootCoord))
	})
	return _c
}

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

func (_c *MockQueryCoord_SetRootCoord_Call) RunAndReturn(run func(types.RootCoord) error) *MockQueryCoord_SetRootCoord_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return r0, r1
}

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

// ShowCollections is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.ShowCollectionsRequest
func (_e *MockQueryCoord_Expecter) ShowCollections(ctx interface{}, req interface{}) *MockQueryCoord_ShowCollections_Call {
	return &MockQueryCoord_ShowCollections_Call{Call: _e.mock.On("ShowCollections", ctx, req)}
}

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

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

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

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

	var r0 *internalpb.ShowConfigurationsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) *internalpb.ShowConfigurationsResponse); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *internalpb.ShowConfigurationsRequest
func (_e *MockQueryCoord_Expecter) ShowConfigurations(ctx interface{}, req interface{}) *MockQueryCoord_ShowConfigurations_Call {
	return &MockQueryCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", ctx, req)}
}

func (_c *MockQueryCoord_ShowConfigurations_Call) Run(run func(ctx context.Context, req *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
}

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

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

	return r0, r1
}

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

// ShowPartitions is a helper method to define mock.On call
//   - ctx context.Context
//   - req *querypb.ShowPartitionsRequest
func (_e *MockQueryCoord_Expecter) ShowPartitions(ctx interface{}, req interface{}) *MockQueryCoord_ShowPartitions_Call {
	return &MockQueryCoord_ShowPartitions_Call{Call: _e.mock.On("ShowPartitions", ctx, req)}
}

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

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

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

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

	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 given fields:
func (_m *MockQueryCoord) Stop() error {
	ret := _m.Called()

	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
}

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

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.SyncNewCreatedPartitionRequest
func (_e *MockQueryCoord_Expecter) SyncNewCreatedPartition(ctx interface{}, req interface{}) *MockQueryCoord_SyncNewCreatedPartition_Call {
	return &MockQueryCoord_SyncNewCreatedPartition_Call{Call: _e.mock.On("SyncNewCreatedPartition", ctx, req)}
}

func (_c *MockQueryCoord_SyncNewCreatedPartition_Call) Run(run func(ctx context.Context, req *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
}

// TransferNode provides a mock function with given fields: ctx, req
func (_m *MockQueryCoord) TransferNode(ctx context.Context, req *milvuspb.TransferNodeRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *milvuspb.TransferNodeRequest
func (_e *MockQueryCoord_Expecter) TransferNode(ctx interface{}, req interface{}) *MockQueryCoord_TransferNode_Call {
	return &MockQueryCoord_TransferNode_Call{Call: _e.mock.On("TransferNode", ctx, req)}
}

func (_c *MockQueryCoord_TransferNode_Call) Run(run func(ctx context.Context, req *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: ctx, req
func (_m *MockQueryCoord) TransferReplica(ctx context.Context, req *querypb.TransferReplicaRequest) (*commonpb.Status, error) {
	ret := _m.Called(ctx, req)

	var r0 *commonpb.Status
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest) (*commonpb.Status, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest) *commonpb.Status); ok {
		r0 = rf(ctx, req)
	} 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(ctx, req)
	} 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
//   - ctx context.Context
//   - req *querypb.TransferReplicaRequest
func (_e *MockQueryCoord_Expecter) TransferReplica(ctx interface{}, req interface{}) *MockQueryCoord_TransferReplica_Call {
	return &MockQueryCoord_TransferReplica_Call{Call: _e.mock.On("TransferReplica", ctx, req)}
}

func (_c *MockQueryCoord_TransferReplica_Call) Run(run func(ctx context.Context, req *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
}

// 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.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
}