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

package mocks

import (
	context "context"

	msgpb "github.com/milvus-io/milvus-proto/go-api/v3/msgpb"
	metastore "github.com/milvus-io/milvus/internal/metastore"
	model "github.com/milvus-io/milvus/internal/metastore/model"
	datapb "github.com/milvus-io/milvus/pkg/v3/proto/datapb"
	indexpb "github.com/milvus-io/milvus/pkg/v3/proto/indexpb"
	internalpb "github.com/milvus-io/milvus/pkg/v3/proto/internalpb"
	mock "github.com/stretchr/testify/mock"
)

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

type DataCoordCatalog_Expecter struct {
	mock *mock.Mock
}

func (_m *DataCoordCatalog) EXPECT() *DataCoordCatalog_Expecter {
	return &DataCoordCatalog_Expecter{mock: &_m.Mock}
}

// AddSegment provides a mock function with given fields: ctx, segment
func (_m *DataCoordCatalog) AddSegment(ctx context.Context, segment *datapb.SegmentInfo) error {
	ret := _m.Called(ctx, segment)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SegmentInfo) error); ok {
		r0 = rf(ctx, segment)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddSegment is a helper method to define mock.On call
//   - ctx context.Context
//   - segment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) AddSegment(ctx interface{}, segment interface{}) *DataCoordCatalog_AddSegment_Call {
	return &DataCoordCatalog_AddSegment_Call{Call: _e.mock.On("AddSegment", ctx, segment)}
}

func (_c *DataCoordCatalog_AddSegment_Call) Run(run func(ctx context.Context, segment *datapb.SegmentInfo)) *DataCoordCatalog_AddSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.SegmentInfo))
	})
	return _c
}

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

func (_c *DataCoordCatalog_AddSegment_Call) RunAndReturn(run func(context.Context, *datapb.SegmentInfo) error) *DataCoordCatalog_AddSegment_Call {
	_c.Call.Return(run)
	return _c
}

// AlterIndexes provides a mock function with given fields: ctx, newIndexes
func (_m *DataCoordCatalog) AlterIndexes(ctx context.Context, newIndexes []*model.Index) error {
	ret := _m.Called(ctx, newIndexes)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*model.Index) error); ok {
		r0 = rf(ctx, newIndexes)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterIndexes is a helper method to define mock.On call
//   - ctx context.Context
//   - newIndexes []*model.Index
func (_e *DataCoordCatalog_Expecter) AlterIndexes(ctx interface{}, newIndexes interface{}) *DataCoordCatalog_AlterIndexes_Call {
	return &DataCoordCatalog_AlterIndexes_Call{Call: _e.mock.On("AlterIndexes", ctx, newIndexes)}
}

func (_c *DataCoordCatalog_AlterIndexes_Call) Run(run func(ctx context.Context, newIndexes []*model.Index)) *DataCoordCatalog_AlterIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*model.Index))
	})
	return _c
}

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

func (_c *DataCoordCatalog_AlterIndexes_Call) RunAndReturn(run func(context.Context, []*model.Index) error) *DataCoordCatalog_AlterIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// AlterSegmentIndexes provides a mock function with given fields: ctx, newSegIdxes
func (_m *DataCoordCatalog) AlterSegmentIndexes(ctx context.Context, newSegIdxes []*model.SegmentIndex) error {
	ret := _m.Called(ctx, newSegIdxes)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*model.SegmentIndex) error); ok {
		r0 = rf(ctx, newSegIdxes)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterSegmentIndexes is a helper method to define mock.On call
//   - ctx context.Context
//   - newSegIdxes []*model.SegmentIndex
func (_e *DataCoordCatalog_Expecter) AlterSegmentIndexes(ctx interface{}, newSegIdxes interface{}) *DataCoordCatalog_AlterSegmentIndexes_Call {
	return &DataCoordCatalog_AlterSegmentIndexes_Call{Call: _e.mock.On("AlterSegmentIndexes", ctx, newSegIdxes)}
}

func (_c *DataCoordCatalog_AlterSegmentIndexes_Call) Run(run func(ctx context.Context, newSegIdxes []*model.SegmentIndex)) *DataCoordCatalog_AlterSegmentIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*model.SegmentIndex))
	})
	return _c
}

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

func (_c *DataCoordCatalog_AlterSegmentIndexes_Call) RunAndReturn(run func(context.Context, []*model.SegmentIndex) error) *DataCoordCatalog_AlterSegmentIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// AlterSegments provides a mock function with given fields: ctx, newSegments, binlogs
func (_m *DataCoordCatalog) AlterSegments(ctx context.Context, newSegments []*datapb.SegmentInfo, binlogs ...metastore.BinlogsIncrement) error {
	_va := make([]interface{}, len(binlogs))
	for _i := range binlogs {
		_va[_i] = binlogs[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, newSegments)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*datapb.SegmentInfo, ...metastore.BinlogsIncrement) error); ok {
		r0 = rf(ctx, newSegments, binlogs...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - newSegments []*datapb.SegmentInfo
//   - binlogs ...metastore.BinlogsIncrement
func (_e *DataCoordCatalog_Expecter) AlterSegments(ctx interface{}, newSegments interface{}, binlogs ...interface{}) *DataCoordCatalog_AlterSegments_Call {
	return &DataCoordCatalog_AlterSegments_Call{Call: _e.mock.On("AlterSegments",
		append([]interface{}{ctx, newSegments}, binlogs...)...)}
}

func (_c *DataCoordCatalog_AlterSegments_Call) Run(run func(ctx context.Context, newSegments []*datapb.SegmentInfo, binlogs ...metastore.BinlogsIncrement)) *DataCoordCatalog_AlterSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]metastore.BinlogsIncrement, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(metastore.BinlogsIncrement)
			}
		}
		run(args[0].(context.Context), args[1].([]*datapb.SegmentInfo), variadicArgs...)
	})
	return _c
}

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

func (_c *DataCoordCatalog_AlterSegments_Call) RunAndReturn(run func(context.Context, []*datapb.SegmentInfo, ...metastore.BinlogsIncrement) error) *DataCoordCatalog_AlterSegments_Call {
	_c.Call.Return(run)
	return _c
}

// ChannelExists provides a mock function with given fields: ctx, channel
func (_m *DataCoordCatalog) ChannelExists(ctx context.Context, channel string) bool {
	ret := _m.Called(ctx, channel)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok {
		r0 = rf(ctx, channel)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ChannelExists is a helper method to define mock.On call
//   - ctx context.Context
//   - channel string
func (_e *DataCoordCatalog_Expecter) ChannelExists(ctx interface{}, channel interface{}) *DataCoordCatalog_ChannelExists_Call {
	return &DataCoordCatalog_ChannelExists_Call{Call: _e.mock.On("ChannelExists", ctx, channel)}
}

func (_c *DataCoordCatalog_ChannelExists_Call) Run(run func(ctx context.Context, channel string)) *DataCoordCatalog_ChannelExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *DataCoordCatalog_ChannelExists_Call) Return(_a0 bool) *DataCoordCatalog_ChannelExists_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataCoordCatalog_ChannelExists_Call) RunAndReturn(run func(context.Context, string) bool) *DataCoordCatalog_ChannelExists_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIndex provides a mock function with given fields: ctx, index
func (_m *DataCoordCatalog) CreateIndex(ctx context.Context, index *model.Index) error {
	ret := _m.Called(ctx, index)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *model.Index) error); ok {
		r0 = rf(ctx, index)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreateIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - index *model.Index
func (_e *DataCoordCatalog_Expecter) CreateIndex(ctx interface{}, index interface{}) *DataCoordCatalog_CreateIndex_Call {
	return &DataCoordCatalog_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, index)}
}

func (_c *DataCoordCatalog_CreateIndex_Call) Run(run func(ctx context.Context, index *model.Index)) *DataCoordCatalog_CreateIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Index))
	})
	return _c
}

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

func (_c *DataCoordCatalog_CreateIndex_Call) RunAndReturn(run func(context.Context, *model.Index) error) *DataCoordCatalog_CreateIndex_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSegmentIndex provides a mock function with given fields: ctx, segIdx
func (_m *DataCoordCatalog) CreateSegmentIndex(ctx context.Context, segIdx *model.SegmentIndex) error {
	ret := _m.Called(ctx, segIdx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *model.SegmentIndex) error); ok {
		r0 = rf(ctx, segIdx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreateSegmentIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - segIdx *model.SegmentIndex
func (_e *DataCoordCatalog_Expecter) CreateSegmentIndex(ctx interface{}, segIdx interface{}) *DataCoordCatalog_CreateSegmentIndex_Call {
	return &DataCoordCatalog_CreateSegmentIndex_Call{Call: _e.mock.On("CreateSegmentIndex", ctx, segIdx)}
}

func (_c *DataCoordCatalog_CreateSegmentIndex_Call) Run(run func(ctx context.Context, segIdx *model.SegmentIndex)) *DataCoordCatalog_CreateSegmentIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.SegmentIndex))
	})
	return _c
}

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

func (_c *DataCoordCatalog_CreateSegmentIndex_Call) RunAndReturn(run func(context.Context, *model.SegmentIndex) error) *DataCoordCatalog_CreateSegmentIndex_Call {
	_c.Call.Return(run)
	return _c
}

// DropChannel provides a mock function with given fields: ctx, channel
func (_m *DataCoordCatalog) DropChannel(ctx context.Context, channel string) error {
	ret := _m.Called(ctx, channel)

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

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

	return r0
}

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

// DropChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - channel string
func (_e *DataCoordCatalog_Expecter) DropChannel(ctx interface{}, channel interface{}) *DataCoordCatalog_DropChannel_Call {
	return &DataCoordCatalog_DropChannel_Call{Call: _e.mock.On("DropChannel", ctx, channel)}
}

func (_c *DataCoordCatalog_DropChannel_Call) Run(run func(ctx context.Context, channel string)) *DataCoordCatalog_DropChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropChannel_Call) RunAndReturn(run func(context.Context, string) error) *DataCoordCatalog_DropChannel_Call {
	_c.Call.Return(run)
	return _c
}

// DropChannelCheckpoint provides a mock function with given fields: ctx, vChannel
func (_m *DataCoordCatalog) DropChannelCheckpoint(ctx context.Context, vChannel string) error {
	ret := _m.Called(ctx, vChannel)

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

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

	return r0
}

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

// DropChannelCheckpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - vChannel string
func (_e *DataCoordCatalog_Expecter) DropChannelCheckpoint(ctx interface{}, vChannel interface{}) *DataCoordCatalog_DropChannelCheckpoint_Call {
	return &DataCoordCatalog_DropChannelCheckpoint_Call{Call: _e.mock.On("DropChannelCheckpoint", ctx, vChannel)}
}

func (_c *DataCoordCatalog_DropChannelCheckpoint_Call) Run(run func(ctx context.Context, vChannel string)) *DataCoordCatalog_DropChannelCheckpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropChannelCheckpoint_Call) RunAndReturn(run func(context.Context, string) error) *DataCoordCatalog_DropChannelCheckpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DropCompactionTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) DropCompactionTask(ctx context.Context, task *datapb.CompactionTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CompactionTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DropCompactionTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *datapb.CompactionTask
func (_e *DataCoordCatalog_Expecter) DropCompactionTask(ctx interface{}, task interface{}) *DataCoordCatalog_DropCompactionTask_Call {
	return &DataCoordCatalog_DropCompactionTask_Call{Call: _e.mock.On("DropCompactionTask", ctx, task)}
}

func (_c *DataCoordCatalog_DropCompactionTask_Call) Run(run func(ctx context.Context, task *datapb.CompactionTask)) *DataCoordCatalog_DropCompactionTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.CompactionTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropCompactionTask_Call) RunAndReturn(run func(context.Context, *datapb.CompactionTask) error) *DataCoordCatalog_DropCompactionTask_Call {
	_c.Call.Return(run)
	return _c
}

// DropCopySegmentJob provides a mock function with given fields: ctx, jobID
func (_m *DataCoordCatalog) DropCopySegmentJob(ctx context.Context, jobID int64) error {
	ret := _m.Called(ctx, jobID)

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

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

	return r0
}

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

// DropCopySegmentJob is a helper method to define mock.On call
//   - ctx context.Context
//   - jobID int64
func (_e *DataCoordCatalog_Expecter) DropCopySegmentJob(ctx interface{}, jobID interface{}) *DataCoordCatalog_DropCopySegmentJob_Call {
	return &DataCoordCatalog_DropCopySegmentJob_Call{Call: _e.mock.On("DropCopySegmentJob", ctx, jobID)}
}

func (_c *DataCoordCatalog_DropCopySegmentJob_Call) Run(run func(ctx context.Context, jobID int64)) *DataCoordCatalog_DropCopySegmentJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropCopySegmentJob_Call) RunAndReturn(run func(context.Context, int64) error) *DataCoordCatalog_DropCopySegmentJob_Call {
	_c.Call.Return(run)
	return _c
}

// DropCopySegmentTask provides a mock function with given fields: ctx, taskID
func (_m *DataCoordCatalog) DropCopySegmentTask(ctx context.Context, taskID int64) error {
	ret := _m.Called(ctx, taskID)

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

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

	return r0
}

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

// DropCopySegmentTask is a helper method to define mock.On call
//   - ctx context.Context
//   - taskID int64
func (_e *DataCoordCatalog_Expecter) DropCopySegmentTask(ctx interface{}, taskID interface{}) *DataCoordCatalog_DropCopySegmentTask_Call {
	return &DataCoordCatalog_DropCopySegmentTask_Call{Call: _e.mock.On("DropCopySegmentTask", ctx, taskID)}
}

func (_c *DataCoordCatalog_DropCopySegmentTask_Call) Run(run func(ctx context.Context, taskID int64)) *DataCoordCatalog_DropCopySegmentTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropCopySegmentTask_Call) RunAndReturn(run func(context.Context, int64) error) *DataCoordCatalog_DropCopySegmentTask_Call {
	_c.Call.Return(run)
	return _c
}

// DropCurrentPartitionStatsVersion provides a mock function with given fields: ctx, collID, partID, vChannel
func (_m *DataCoordCatalog) DropCurrentPartitionStatsVersion(ctx context.Context, collID int64, partID int64, vChannel string) error {
	ret := _m.Called(ctx, collID, partID, vChannel)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64, string) error); ok {
		r0 = rf(ctx, collID, partID, vChannel)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DropCurrentPartitionStatsVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - collID int64
//   - partID int64
//   - vChannel string
func (_e *DataCoordCatalog_Expecter) DropCurrentPartitionStatsVersion(ctx interface{}, collID interface{}, partID interface{}, vChannel interface{}) *DataCoordCatalog_DropCurrentPartitionStatsVersion_Call {
	return &DataCoordCatalog_DropCurrentPartitionStatsVersion_Call{Call: _e.mock.On("DropCurrentPartitionStatsVersion", ctx, collID, partID, vChannel)}
}

func (_c *DataCoordCatalog_DropCurrentPartitionStatsVersion_Call) Run(run func(ctx context.Context, collID int64, partID int64, vChannel string)) *DataCoordCatalog_DropCurrentPartitionStatsVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(string))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropCurrentPartitionStatsVersion_Call) RunAndReturn(run func(context.Context, int64, int64, string) error) *DataCoordCatalog_DropCurrentPartitionStatsVersion_Call {
	_c.Call.Return(run)
	return _c
}

// DropImportJob provides a mock function with given fields: ctx, jobID
func (_m *DataCoordCatalog) DropImportJob(ctx context.Context, jobID int64) error {
	ret := _m.Called(ctx, jobID)

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

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

	return r0
}

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

// DropImportJob is a helper method to define mock.On call
//   - ctx context.Context
//   - jobID int64
func (_e *DataCoordCatalog_Expecter) DropImportJob(ctx interface{}, jobID interface{}) *DataCoordCatalog_DropImportJob_Call {
	return &DataCoordCatalog_DropImportJob_Call{Call: _e.mock.On("DropImportJob", ctx, jobID)}
}

func (_c *DataCoordCatalog_DropImportJob_Call) Run(run func(ctx context.Context, jobID int64)) *DataCoordCatalog_DropImportJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropImportJob_Call) RunAndReturn(run func(context.Context, int64) error) *DataCoordCatalog_DropImportJob_Call {
	_c.Call.Return(run)
	return _c
}

// DropImportTask provides a mock function with given fields: ctx, taskID
func (_m *DataCoordCatalog) DropImportTask(ctx context.Context, taskID int64) error {
	ret := _m.Called(ctx, taskID)

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

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

	return r0
}

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

// DropImportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - taskID int64
func (_e *DataCoordCatalog_Expecter) DropImportTask(ctx interface{}, taskID interface{}) *DataCoordCatalog_DropImportTask_Call {
	return &DataCoordCatalog_DropImportTask_Call{Call: _e.mock.On("DropImportTask", ctx, taskID)}
}

func (_c *DataCoordCatalog_DropImportTask_Call) Run(run func(ctx context.Context, taskID int64)) *DataCoordCatalog_DropImportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropImportTask_Call) RunAndReturn(run func(context.Context, int64) error) *DataCoordCatalog_DropImportTask_Call {
	_c.Call.Return(run)
	return _c
}

// DropIndex provides a mock function with given fields: ctx, collID, dropIdxID
func (_m *DataCoordCatalog) DropIndex(ctx context.Context, collID int64, dropIdxID int64) error {
	ret := _m.Called(ctx, collID, dropIdxID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64) error); ok {
		r0 = rf(ctx, collID, dropIdxID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DropIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - collID int64
//   - dropIdxID int64
func (_e *DataCoordCatalog_Expecter) DropIndex(ctx interface{}, collID interface{}, dropIdxID interface{}) *DataCoordCatalog_DropIndex_Call {
	return &DataCoordCatalog_DropIndex_Call{Call: _e.mock.On("DropIndex", ctx, collID, dropIdxID)}
}

func (_c *DataCoordCatalog_DropIndex_Call) Run(run func(ctx context.Context, collID int64, dropIdxID int64)) *DataCoordCatalog_DropIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropIndex_Call) RunAndReturn(run func(context.Context, int64, int64) error) *DataCoordCatalog_DropIndex_Call {
	_c.Call.Return(run)
	return _c
}

// DropPreImportTask provides a mock function with given fields: ctx, taskID
func (_m *DataCoordCatalog) DropPreImportTask(ctx context.Context, taskID int64) error {
	ret := _m.Called(ctx, taskID)

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

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

	return r0
}

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

// DropPreImportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - taskID int64
func (_e *DataCoordCatalog_Expecter) DropPreImportTask(ctx interface{}, taskID interface{}) *DataCoordCatalog_DropPreImportTask_Call {
	return &DataCoordCatalog_DropPreImportTask_Call{Call: _e.mock.On("DropPreImportTask", ctx, taskID)}
}

func (_c *DataCoordCatalog_DropPreImportTask_Call) Run(run func(ctx context.Context, taskID int64)) *DataCoordCatalog_DropPreImportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropPreImportTask_Call) RunAndReturn(run func(context.Context, int64) error) *DataCoordCatalog_DropPreImportTask_Call {
	_c.Call.Return(run)
	return _c
}

// DropSegment provides a mock function with given fields: ctx, segment
func (_m *DataCoordCatalog) DropSegment(ctx context.Context, segment *datapb.SegmentInfo) error {
	ret := _m.Called(ctx, segment)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SegmentInfo) error); ok {
		r0 = rf(ctx, segment)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DropSegment is a helper method to define mock.On call
//   - ctx context.Context
//   - segment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) DropSegment(ctx interface{}, segment interface{}) *DataCoordCatalog_DropSegment_Call {
	return &DataCoordCatalog_DropSegment_Call{Call: _e.mock.On("DropSegment", ctx, segment)}
}

func (_c *DataCoordCatalog_DropSegment_Call) Run(run func(ctx context.Context, segment *datapb.SegmentInfo)) *DataCoordCatalog_DropSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.SegmentInfo))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropSegment_Call) RunAndReturn(run func(context.Context, *datapb.SegmentInfo) error) *DataCoordCatalog_DropSegment_Call {
	_c.Call.Return(run)
	return _c
}

// DropSegmentIndex provides a mock function with given fields: ctx, collID, partID, segID, buildID
func (_m *DataCoordCatalog) DropSegmentIndex(ctx context.Context, collID int64, partID int64, segID int64, buildID int64) error {
	ret := _m.Called(ctx, collID, partID, segID, buildID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64, int64, int64) error); ok {
		r0 = rf(ctx, collID, partID, segID, buildID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DropSegmentIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - collID int64
//   - partID int64
//   - segID int64
//   - buildID int64
func (_e *DataCoordCatalog_Expecter) DropSegmentIndex(ctx interface{}, collID interface{}, partID interface{}, segID interface{}, buildID interface{}) *DataCoordCatalog_DropSegmentIndex_Call {
	return &DataCoordCatalog_DropSegmentIndex_Call{Call: _e.mock.On("DropSegmentIndex", ctx, collID, partID, segID, buildID)}
}

func (_c *DataCoordCatalog_DropSegmentIndex_Call) Run(run func(ctx context.Context, collID int64, partID int64, segID int64, buildID int64)) *DataCoordCatalog_DropSegmentIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(int64), args[4].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropSegmentIndex_Call) RunAndReturn(run func(context.Context, int64, int64, int64, int64) error) *DataCoordCatalog_DropSegmentIndex_Call {
	_c.Call.Return(run)
	return _c
}

// DropSnapshot provides a mock function with given fields: ctx, collectionID, snapshotID
func (_m *DataCoordCatalog) DropSnapshot(ctx context.Context, collectionID int64, snapshotID int64) error {
	ret := _m.Called(ctx, collectionID, snapshotID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64) error); ok {
		r0 = rf(ctx, collectionID, snapshotID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DropSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - collectionID int64
//   - snapshotID int64
func (_e *DataCoordCatalog_Expecter) DropSnapshot(ctx interface{}, collectionID interface{}, snapshotID interface{}) *DataCoordCatalog_DropSnapshot_Call {
	return &DataCoordCatalog_DropSnapshot_Call{Call: _e.mock.On("DropSnapshot", ctx, collectionID, snapshotID)}
}

func (_c *DataCoordCatalog_DropSnapshot_Call) Run(run func(ctx context.Context, collectionID int64, snapshotID int64)) *DataCoordCatalog_DropSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropSnapshot_Call) RunAndReturn(run func(context.Context, int64, int64) error) *DataCoordCatalog_DropSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// DropStatsTask provides a mock function with given fields: ctx, taskID
func (_m *DataCoordCatalog) DropStatsTask(ctx context.Context, taskID int64) error {
	ret := _m.Called(ctx, taskID)

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

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

	return r0
}

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

// DropStatsTask is a helper method to define mock.On call
//   - ctx context.Context
//   - taskID int64
func (_e *DataCoordCatalog_Expecter) DropStatsTask(ctx interface{}, taskID interface{}) *DataCoordCatalog_DropStatsTask_Call {
	return &DataCoordCatalog_DropStatsTask_Call{Call: _e.mock.On("DropStatsTask", ctx, taskID)}
}

func (_c *DataCoordCatalog_DropStatsTask_Call) Run(run func(ctx context.Context, taskID int64)) *DataCoordCatalog_DropStatsTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_DropStatsTask_Call) RunAndReturn(run func(context.Context, int64) error) *DataCoordCatalog_DropStatsTask_Call {
	_c.Call.Return(run)
	return _c
}

// GcConfirm provides a mock function with given fields: ctx, collectionID, partitionID
func (_m *DataCoordCatalog) GcConfirm(ctx context.Context, collectionID int64, partitionID int64) bool {
	ret := _m.Called(ctx, collectionID, partitionID)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64) bool); ok {
		r0 = rf(ctx, collectionID, partitionID)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// GcConfirm is a helper method to define mock.On call
//   - ctx context.Context
//   - collectionID int64
//   - partitionID int64
func (_e *DataCoordCatalog_Expecter) GcConfirm(ctx interface{}, collectionID interface{}, partitionID interface{}) *DataCoordCatalog_GcConfirm_Call {
	return &DataCoordCatalog_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, collectionID, partitionID)}
}

func (_c *DataCoordCatalog_GcConfirm_Call) Run(run func(ctx context.Context, collectionID int64, partitionID int64)) *DataCoordCatalog_GcConfirm_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64))
	})
	return _c
}

func (_c *DataCoordCatalog_GcConfirm_Call) Return(_a0 bool) *DataCoordCatalog_GcConfirm_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataCoordCatalog_GcConfirm_Call) RunAndReturn(run func(context.Context, int64, int64) bool) *DataCoordCatalog_GcConfirm_Call {
	_c.Call.Return(run)
	return _c
}

// GetCurrentPartitionStatsVersion provides a mock function with given fields: ctx, collID, partID, vChannel
func (_m *DataCoordCatalog) GetCurrentPartitionStatsVersion(ctx context.Context, collID int64, partID int64, vChannel string) (int64, error) {
	ret := _m.Called(ctx, collID, partID, vChannel)

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

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64, string) (int64, error)); ok {
		return rf(ctx, collID, partID, vChannel)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64, string) int64); ok {
		r0 = rf(ctx, collID, partID, vChannel)
	} else {
		r0 = ret.Get(0).(int64)
	}

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

	return r0, r1
}

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

// GetCurrentPartitionStatsVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - collID int64
//   - partID int64
//   - vChannel string
func (_e *DataCoordCatalog_Expecter) GetCurrentPartitionStatsVersion(ctx interface{}, collID interface{}, partID interface{}, vChannel interface{}) *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call {
	return &DataCoordCatalog_GetCurrentPartitionStatsVersion_Call{Call: _e.mock.On("GetCurrentPartitionStatsVersion", ctx, collID, partID, vChannel)}
}

func (_c *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call) Run(run func(ctx context.Context, collID int64, partID int64, vChannel string)) *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(string))
	})
	return _c
}

func (_c *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call) Return(_a0 int64, _a1 error) *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call) RunAndReturn(run func(context.Context, int64, int64, string) (int64, error)) *DataCoordCatalog_GetCurrentPartitionStatsVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ListAnalyzeTasks provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListAnalyzeTasks(ctx context.Context) ([]*indexpb.AnalyzeTask, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListAnalyzeTasks_Call) Return(_a0 []*indexpb.AnalyzeTask, _a1 error) *DataCoordCatalog_ListAnalyzeTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListAnalyzeTasks_Call) RunAndReturn(run func(context.Context) ([]*indexpb.AnalyzeTask, error)) *DataCoordCatalog_ListAnalyzeTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ListChannelCheckpoint provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListChannelCheckpoint(ctx context.Context) (map[string]*msgpb.MsgPosition, error) {
	ret := _m.Called(ctx)

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

	var r0 map[string]*msgpb.MsgPosition
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (map[string]*msgpb.MsgPosition, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) map[string]*msgpb.MsgPosition); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*msgpb.MsgPosition)
		}
	}

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListChannelCheckpoint_Call) Return(_a0 map[string]*msgpb.MsgPosition, _a1 error) *DataCoordCatalog_ListChannelCheckpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListChannelCheckpoint_Call) RunAndReturn(run func(context.Context) (map[string]*msgpb.MsgPosition, error)) *DataCoordCatalog_ListChannelCheckpoint_Call {
	_c.Call.Return(run)
	return _c
}

// ListCompactionTask provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListCompactionTask(ctx context.Context) ([]*datapb.CompactionTask, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListCompactionTask_Call) Return(_a0 []*datapb.CompactionTask, _a1 error) *DataCoordCatalog_ListCompactionTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListCompactionTask_Call) RunAndReturn(run func(context.Context) ([]*datapb.CompactionTask, error)) *DataCoordCatalog_ListCompactionTask_Call {
	_c.Call.Return(run)
	return _c
}

// ListCopySegmentJobs provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListCopySegmentJobs(ctx context.Context) ([]*datapb.CopySegmentJob, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListCopySegmentJobs_Call) Return(_a0 []*datapb.CopySegmentJob, _a1 error) *DataCoordCatalog_ListCopySegmentJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListCopySegmentJobs_Call) RunAndReturn(run func(context.Context) ([]*datapb.CopySegmentJob, error)) *DataCoordCatalog_ListCopySegmentJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListCopySegmentTasks provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListCopySegmentTasks(ctx context.Context) ([]*datapb.CopySegmentTask, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListCopySegmentTasks_Call) Return(_a0 []*datapb.CopySegmentTask, _a1 error) *DataCoordCatalog_ListCopySegmentTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListCopySegmentTasks_Call) RunAndReturn(run func(context.Context) ([]*datapb.CopySegmentTask, error)) *DataCoordCatalog_ListCopySegmentTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ListExternalCollectionRefreshJobs provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListExternalCollectionRefreshJobs(ctx context.Context) ([]*datapb.ExternalCollectionRefreshJob, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListExternalCollectionRefreshJobs_Call) Return(_a0 []*datapb.ExternalCollectionRefreshJob, _a1 error) *DataCoordCatalog_ListExternalCollectionRefreshJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListExternalCollectionRefreshJobs_Call) RunAndReturn(run func(context.Context) ([]*datapb.ExternalCollectionRefreshJob, error)) *DataCoordCatalog_ListExternalCollectionRefreshJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListExternalCollectionRefreshTasks provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListExternalCollectionRefreshTasks(ctx context.Context) ([]*datapb.ExternalCollectionRefreshTask, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListExternalCollectionRefreshTasks_Call) Return(_a0 []*datapb.ExternalCollectionRefreshTask, _a1 error) *DataCoordCatalog_ListExternalCollectionRefreshTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListExternalCollectionRefreshTasks_Call) RunAndReturn(run func(context.Context) ([]*datapb.ExternalCollectionRefreshTask, error)) *DataCoordCatalog_ListExternalCollectionRefreshTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ListFileResource provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListFileResource(ctx context.Context) ([]*internalpb.FileResourceInfo, uint64, error) {
	ret := _m.Called(ctx)

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

	var r0 []*internalpb.FileResourceInfo
	var r1 uint64
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*internalpb.FileResourceInfo, uint64, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*internalpb.FileResourceInfo); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*internalpb.FileResourceInfo)
		}
	}

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

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

	return r0, r1, r2
}

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

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

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

func (_c *DataCoordCatalog_ListFileResource_Call) Return(_a0 []*internalpb.FileResourceInfo, _a1 uint64, _a2 error) *DataCoordCatalog_ListFileResource_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataCoordCatalog_ListFileResource_Call) RunAndReturn(run func(context.Context) ([]*internalpb.FileResourceInfo, uint64, error)) *DataCoordCatalog_ListFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// ListImportJobs provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListImportJobs(ctx context.Context) ([]*datapb.ImportJob, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListImportJobs_Call) Return(_a0 []*datapb.ImportJob, _a1 error) *DataCoordCatalog_ListImportJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListImportJobs_Call) RunAndReturn(run func(context.Context) ([]*datapb.ImportJob, error)) *DataCoordCatalog_ListImportJobs_Call {
	_c.Call.Return(run)
	return _c
}

// ListImportTasks provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListImportTasks(ctx context.Context) ([]*datapb.ImportTaskV2, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListImportTasks_Call) Return(_a0 []*datapb.ImportTaskV2, _a1 error) *DataCoordCatalog_ListImportTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListImportTasks_Call) RunAndReturn(run func(context.Context) ([]*datapb.ImportTaskV2, error)) *DataCoordCatalog_ListImportTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ListIndexes provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListIndexes(ctx context.Context) ([]*model.Index, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListIndexes_Call) Return(_a0 []*model.Index, _a1 error) *DataCoordCatalog_ListIndexes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListIndexes_Call) RunAndReturn(run func(context.Context) ([]*model.Index, error)) *DataCoordCatalog_ListIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// ListPartitionStatsInfos provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListPartitionStatsInfos(ctx context.Context) ([]*datapb.PartitionStatsInfo, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListPartitionStatsInfos_Call) Return(_a0 []*datapb.PartitionStatsInfo, _a1 error) *DataCoordCatalog_ListPartitionStatsInfos_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListPartitionStatsInfos_Call) RunAndReturn(run func(context.Context) ([]*datapb.PartitionStatsInfo, error)) *DataCoordCatalog_ListPartitionStatsInfos_Call {
	_c.Call.Return(run)
	return _c
}

// ListPreImportTasks provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListPreImportTasks(ctx context.Context) ([]*datapb.PreImportTask, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListPreImportTasks_Call) Return(_a0 []*datapb.PreImportTask, _a1 error) *DataCoordCatalog_ListPreImportTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListPreImportTasks_Call) RunAndReturn(run func(context.Context) ([]*datapb.PreImportTask, error)) *DataCoordCatalog_ListPreImportTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ListSegmentIndexes provides a mock function with given fields: ctx, collectionID
func (_m *DataCoordCatalog) ListSegmentIndexes(ctx context.Context, collectionID int64) ([]*model.SegmentIndex, error) {
	ret := _m.Called(ctx, collectionID)

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

	var r0 []*model.SegmentIndex
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) ([]*model.SegmentIndex, error)); ok {
		return rf(ctx, collectionID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) []*model.SegmentIndex); ok {
		r0 = rf(ctx, collectionID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.SegmentIndex)
		}
	}

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

	return r0, r1
}

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

// ListSegmentIndexes is a helper method to define mock.On call
//   - ctx context.Context
//   - collectionID int64
func (_e *DataCoordCatalog_Expecter) ListSegmentIndexes(ctx interface{}, collectionID interface{}) *DataCoordCatalog_ListSegmentIndexes_Call {
	return &DataCoordCatalog_ListSegmentIndexes_Call{Call: _e.mock.On("ListSegmentIndexes", ctx, collectionID)}
}

func (_c *DataCoordCatalog_ListSegmentIndexes_Call) Run(run func(ctx context.Context, collectionID int64)) *DataCoordCatalog_ListSegmentIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

func (_c *DataCoordCatalog_ListSegmentIndexes_Call) Return(_a0 []*model.SegmentIndex, _a1 error) *DataCoordCatalog_ListSegmentIndexes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListSegmentIndexes_Call) RunAndReturn(run func(context.Context, int64) ([]*model.SegmentIndex, error)) *DataCoordCatalog_ListSegmentIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// ListSegments provides a mock function with given fields: ctx, collectionID
func (_m *DataCoordCatalog) ListSegments(ctx context.Context, collectionID int64) ([]*datapb.SegmentInfo, error) {
	ret := _m.Called(ctx, collectionID)

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

	var r0 []*datapb.SegmentInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) ([]*datapb.SegmentInfo, error)); ok {
		return rf(ctx, collectionID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) []*datapb.SegmentInfo); ok {
		r0 = rf(ctx, collectionID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*datapb.SegmentInfo)
		}
	}

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

	return r0, r1
}

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

// ListSegments is a helper method to define mock.On call
//   - ctx context.Context
//   - collectionID int64
func (_e *DataCoordCatalog_Expecter) ListSegments(ctx interface{}, collectionID interface{}) *DataCoordCatalog_ListSegments_Call {
	return &DataCoordCatalog_ListSegments_Call{Call: _e.mock.On("ListSegments", ctx, collectionID)}
}

func (_c *DataCoordCatalog_ListSegments_Call) Run(run func(ctx context.Context, collectionID int64)) *DataCoordCatalog_ListSegments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

func (_c *DataCoordCatalog_ListSegments_Call) Return(_a0 []*datapb.SegmentInfo, _a1 error) *DataCoordCatalog_ListSegments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListSegments_Call) RunAndReturn(run func(context.Context, int64) ([]*datapb.SegmentInfo, error)) *DataCoordCatalog_ListSegments_Call {
	_c.Call.Return(run)
	return _c
}

// ListSnapshots provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListSnapshots(ctx context.Context) ([]*datapb.SnapshotInfo, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListSnapshots_Call) Return(_a0 []*datapb.SnapshotInfo, _a1 error) *DataCoordCatalog_ListSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListSnapshots_Call) RunAndReturn(run func(context.Context) ([]*datapb.SnapshotInfo, error)) *DataCoordCatalog_ListSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// ListStatsTasks provides a mock function with given fields: ctx
func (_m *DataCoordCatalog) ListStatsTasks(ctx context.Context) ([]*indexpb.StatsTask, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

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

func (_c *DataCoordCatalog_ListStatsTasks_Call) Return(_a0 []*indexpb.StatsTask, _a1 error) *DataCoordCatalog_ListStatsTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DataCoordCatalog_ListStatsTasks_Call) RunAndReturn(run func(context.Context) ([]*indexpb.StatsTask, error)) *DataCoordCatalog_ListStatsTasks_Call {
	_c.Call.Return(run)
	return _c
}

// MarkChannelAdded provides a mock function with given fields: ctx, channel
func (_m *DataCoordCatalog) MarkChannelAdded(ctx context.Context, channel string) error {
	ret := _m.Called(ctx, channel)

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

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

	return r0
}

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

// MarkChannelAdded is a helper method to define mock.On call
//   - ctx context.Context
//   - channel string
func (_e *DataCoordCatalog_Expecter) MarkChannelAdded(ctx interface{}, channel interface{}) *DataCoordCatalog_MarkChannelAdded_Call {
	return &DataCoordCatalog_MarkChannelAdded_Call{Call: _e.mock.On("MarkChannelAdded", ctx, channel)}
}

func (_c *DataCoordCatalog_MarkChannelAdded_Call) Run(run func(ctx context.Context, channel string)) *DataCoordCatalog_MarkChannelAdded_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

func (_c *DataCoordCatalog_MarkChannelAdded_Call) RunAndReturn(run func(context.Context, string) error) *DataCoordCatalog_MarkChannelAdded_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveFileResource provides a mock function with given fields: ctx, resourceID, version
func (_m *DataCoordCatalog) RemoveFileResource(ctx context.Context, resourceID int64, version uint64) error {
	ret := _m.Called(ctx, resourceID, version)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, uint64) error); ok {
		r0 = rf(ctx, resourceID, version)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RemoveFileResource is a helper method to define mock.On call
//   - ctx context.Context
//   - resourceID int64
//   - version uint64
func (_e *DataCoordCatalog_Expecter) RemoveFileResource(ctx interface{}, resourceID interface{}, version interface{}) *DataCoordCatalog_RemoveFileResource_Call {
	return &DataCoordCatalog_RemoveFileResource_Call{Call: _e.mock.On("RemoveFileResource", ctx, resourceID, version)}
}

func (_c *DataCoordCatalog_RemoveFileResource_Call) Run(run func(ctx context.Context, resourceID int64, version uint64)) *DataCoordCatalog_RemoveFileResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(uint64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_RemoveFileResource_Call) RunAndReturn(run func(context.Context, int64, uint64) error) *DataCoordCatalog_RemoveFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// SaveAnalyzeTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SaveAnalyzeTask(ctx context.Context, task *indexpb.AnalyzeTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.AnalyzeTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveAnalyzeTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *indexpb.AnalyzeTask
func (_e *DataCoordCatalog_Expecter) SaveAnalyzeTask(ctx interface{}, task interface{}) *DataCoordCatalog_SaveAnalyzeTask_Call {
	return &DataCoordCatalog_SaveAnalyzeTask_Call{Call: _e.mock.On("SaveAnalyzeTask", ctx, task)}
}

func (_c *DataCoordCatalog_SaveAnalyzeTask_Call) Run(run func(ctx context.Context, task *indexpb.AnalyzeTask)) *DataCoordCatalog_SaveAnalyzeTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*indexpb.AnalyzeTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveAnalyzeTask_Call) RunAndReturn(run func(context.Context, *indexpb.AnalyzeTask) error) *DataCoordCatalog_SaveAnalyzeTask_Call {
	_c.Call.Return(run)
	return _c
}

// SaveChannelCheckpoint provides a mock function with given fields: ctx, vChannel, pos
func (_m *DataCoordCatalog) SaveChannelCheckpoint(ctx context.Context, vChannel string, pos *msgpb.MsgPosition) error {
	ret := _m.Called(ctx, vChannel, pos)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *msgpb.MsgPosition) error); ok {
		r0 = rf(ctx, vChannel, pos)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveChannelCheckpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - vChannel string
//   - pos *msgpb.MsgPosition
func (_e *DataCoordCatalog_Expecter) SaveChannelCheckpoint(ctx interface{}, vChannel interface{}, pos interface{}) *DataCoordCatalog_SaveChannelCheckpoint_Call {
	return &DataCoordCatalog_SaveChannelCheckpoint_Call{Call: _e.mock.On("SaveChannelCheckpoint", ctx, vChannel, pos)}
}

func (_c *DataCoordCatalog_SaveChannelCheckpoint_Call) Run(run func(ctx context.Context, vChannel string, pos *msgpb.MsgPosition)) *DataCoordCatalog_SaveChannelCheckpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*msgpb.MsgPosition))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveChannelCheckpoint_Call) RunAndReturn(run func(context.Context, string, *msgpb.MsgPosition) error) *DataCoordCatalog_SaveChannelCheckpoint_Call {
	_c.Call.Return(run)
	return _c
}

// SaveChannelCheckpoints provides a mock function with given fields: ctx, positions
func (_m *DataCoordCatalog) SaveChannelCheckpoints(ctx context.Context, positions []*msgpb.MsgPosition) error {
	ret := _m.Called(ctx, positions)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*msgpb.MsgPosition) error); ok {
		r0 = rf(ctx, positions)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveChannelCheckpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - positions []*msgpb.MsgPosition
func (_e *DataCoordCatalog_Expecter) SaveChannelCheckpoints(ctx interface{}, positions interface{}) *DataCoordCatalog_SaveChannelCheckpoints_Call {
	return &DataCoordCatalog_SaveChannelCheckpoints_Call{Call: _e.mock.On("SaveChannelCheckpoints", ctx, positions)}
}

func (_c *DataCoordCatalog_SaveChannelCheckpoints_Call) Run(run func(ctx context.Context, positions []*msgpb.MsgPosition)) *DataCoordCatalog_SaveChannelCheckpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*msgpb.MsgPosition))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveChannelCheckpoints_Call) RunAndReturn(run func(context.Context, []*msgpb.MsgPosition) error) *DataCoordCatalog_SaveChannelCheckpoints_Call {
	_c.Call.Return(run)
	return _c
}

// SaveCompactionTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SaveCompactionTask(ctx context.Context, task *datapb.CompactionTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CompactionTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveCompactionTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *datapb.CompactionTask
func (_e *DataCoordCatalog_Expecter) SaveCompactionTask(ctx interface{}, task interface{}) *DataCoordCatalog_SaveCompactionTask_Call {
	return &DataCoordCatalog_SaveCompactionTask_Call{Call: _e.mock.On("SaveCompactionTask", ctx, task)}
}

func (_c *DataCoordCatalog_SaveCompactionTask_Call) Run(run func(ctx context.Context, task *datapb.CompactionTask)) *DataCoordCatalog_SaveCompactionTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.CompactionTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveCompactionTask_Call) RunAndReturn(run func(context.Context, *datapb.CompactionTask) error) *DataCoordCatalog_SaveCompactionTask_Call {
	_c.Call.Return(run)
	return _c
}

// SaveCopySegmentJob provides a mock function with given fields: ctx, job
func (_m *DataCoordCatalog) SaveCopySegmentJob(ctx context.Context, job *datapb.CopySegmentJob) error {
	ret := _m.Called(ctx, job)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CopySegmentJob) error); ok {
		r0 = rf(ctx, job)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveCopySegmentJob is a helper method to define mock.On call
//   - ctx context.Context
//   - job *datapb.CopySegmentJob
func (_e *DataCoordCatalog_Expecter) SaveCopySegmentJob(ctx interface{}, job interface{}) *DataCoordCatalog_SaveCopySegmentJob_Call {
	return &DataCoordCatalog_SaveCopySegmentJob_Call{Call: _e.mock.On("SaveCopySegmentJob", ctx, job)}
}

func (_c *DataCoordCatalog_SaveCopySegmentJob_Call) Run(run func(ctx context.Context, job *datapb.CopySegmentJob)) *DataCoordCatalog_SaveCopySegmentJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.CopySegmentJob))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveCopySegmentJob_Call) RunAndReturn(run func(context.Context, *datapb.CopySegmentJob) error) *DataCoordCatalog_SaveCopySegmentJob_Call {
	_c.Call.Return(run)
	return _c
}

// SaveCopySegmentTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SaveCopySegmentTask(ctx context.Context, task *datapb.CopySegmentTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.CopySegmentTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveCopySegmentTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *datapb.CopySegmentTask
func (_e *DataCoordCatalog_Expecter) SaveCopySegmentTask(ctx interface{}, task interface{}) *DataCoordCatalog_SaveCopySegmentTask_Call {
	return &DataCoordCatalog_SaveCopySegmentTask_Call{Call: _e.mock.On("SaveCopySegmentTask", ctx, task)}
}

func (_c *DataCoordCatalog_SaveCopySegmentTask_Call) Run(run func(ctx context.Context, task *datapb.CopySegmentTask)) *DataCoordCatalog_SaveCopySegmentTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.CopySegmentTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveCopySegmentTask_Call) RunAndReturn(run func(context.Context, *datapb.CopySegmentTask) error) *DataCoordCatalog_SaveCopySegmentTask_Call {
	_c.Call.Return(run)
	return _c
}

// SaveCopySegmentTasksBatch provides a mock function with given fields: ctx, tasks
func (_m *DataCoordCatalog) SaveCopySegmentTasksBatch(ctx context.Context, tasks []*datapb.CopySegmentTask) error {
	ret := _m.Called(ctx, tasks)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*datapb.CopySegmentTask) error); ok {
		r0 = rf(ctx, tasks)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveCopySegmentTasksBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - tasks []*datapb.CopySegmentTask
func (_e *DataCoordCatalog_Expecter) SaveCopySegmentTasksBatch(ctx interface{}, tasks interface{}) *DataCoordCatalog_SaveCopySegmentTasksBatch_Call {
	return &DataCoordCatalog_SaveCopySegmentTasksBatch_Call{Call: _e.mock.On("SaveCopySegmentTasksBatch", ctx, tasks)}
}

func (_c *DataCoordCatalog_SaveCopySegmentTasksBatch_Call) Run(run func(ctx context.Context, tasks []*datapb.CopySegmentTask)) *DataCoordCatalog_SaveCopySegmentTasksBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*datapb.CopySegmentTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveCopySegmentTasksBatch_Call) RunAndReturn(run func(context.Context, []*datapb.CopySegmentTask) error) *DataCoordCatalog_SaveCopySegmentTasksBatch_Call {
	_c.Call.Return(run)
	return _c
}

// SaveDroppedSegmentsInBatch provides a mock function with given fields: ctx, segments
func (_m *DataCoordCatalog) SaveDroppedSegmentsInBatch(ctx context.Context, segments []*datapb.SegmentInfo) error {
	ret := _m.Called(ctx, segments)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []*datapb.SegmentInfo) error); ok {
		r0 = rf(ctx, segments)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveDroppedSegmentsInBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - segments []*datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) SaveDroppedSegmentsInBatch(ctx interface{}, segments interface{}) *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call {
	return &DataCoordCatalog_SaveDroppedSegmentsInBatch_Call{Call: _e.mock.On("SaveDroppedSegmentsInBatch", ctx, segments)}
}

func (_c *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call) Run(run func(ctx context.Context, segments []*datapb.SegmentInfo)) *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*datapb.SegmentInfo))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call) RunAndReturn(run func(context.Context, []*datapb.SegmentInfo) error) *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call {
	_c.Call.Return(run)
	return _c
}

// SaveExternalCollectionRefreshJob provides a mock function with given fields: ctx, job
func (_m *DataCoordCatalog) SaveExternalCollectionRefreshJob(ctx context.Context, job *datapb.ExternalCollectionRefreshJob) error {
	ret := _m.Called(ctx, job)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ExternalCollectionRefreshJob) error); ok {
		r0 = rf(ctx, job)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveExternalCollectionRefreshJob is a helper method to define mock.On call
//   - ctx context.Context
//   - job *datapb.ExternalCollectionRefreshJob
func (_e *DataCoordCatalog_Expecter) SaveExternalCollectionRefreshJob(ctx interface{}, job interface{}) *DataCoordCatalog_SaveExternalCollectionRefreshJob_Call {
	return &DataCoordCatalog_SaveExternalCollectionRefreshJob_Call{Call: _e.mock.On("SaveExternalCollectionRefreshJob", ctx, job)}
}

func (_c *DataCoordCatalog_SaveExternalCollectionRefreshJob_Call) Run(run func(ctx context.Context, job *datapb.ExternalCollectionRefreshJob)) *DataCoordCatalog_SaveExternalCollectionRefreshJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.ExternalCollectionRefreshJob))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveExternalCollectionRefreshJob_Call) RunAndReturn(run func(context.Context, *datapb.ExternalCollectionRefreshJob) error) *DataCoordCatalog_SaveExternalCollectionRefreshJob_Call {
	_c.Call.Return(run)
	return _c
}

// SaveExternalCollectionRefreshTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SaveExternalCollectionRefreshTask(ctx context.Context, task *datapb.ExternalCollectionRefreshTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ExternalCollectionRefreshTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveExternalCollectionRefreshTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *datapb.ExternalCollectionRefreshTask
func (_e *DataCoordCatalog_Expecter) SaveExternalCollectionRefreshTask(ctx interface{}, task interface{}) *DataCoordCatalog_SaveExternalCollectionRefreshTask_Call {
	return &DataCoordCatalog_SaveExternalCollectionRefreshTask_Call{Call: _e.mock.On("SaveExternalCollectionRefreshTask", ctx, task)}
}

func (_c *DataCoordCatalog_SaveExternalCollectionRefreshTask_Call) Run(run func(ctx context.Context, task *datapb.ExternalCollectionRefreshTask)) *DataCoordCatalog_SaveExternalCollectionRefreshTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.ExternalCollectionRefreshTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveExternalCollectionRefreshTask_Call) RunAndReturn(run func(context.Context, *datapb.ExternalCollectionRefreshTask) error) *DataCoordCatalog_SaveExternalCollectionRefreshTask_Call {
	_c.Call.Return(run)
	return _c
}

// SaveFileResource provides a mock function with given fields: ctx, resource, version
func (_m *DataCoordCatalog) SaveFileResource(ctx context.Context, resource *internalpb.FileResourceInfo, version uint64) error {
	ret := _m.Called(ctx, resource, version)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *internalpb.FileResourceInfo, uint64) error); ok {
		r0 = rf(ctx, resource, version)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveFileResource is a helper method to define mock.On call
//   - ctx context.Context
//   - resource *internalpb.FileResourceInfo
//   - version uint64
func (_e *DataCoordCatalog_Expecter) SaveFileResource(ctx interface{}, resource interface{}, version interface{}) *DataCoordCatalog_SaveFileResource_Call {
	return &DataCoordCatalog_SaveFileResource_Call{Call: _e.mock.On("SaveFileResource", ctx, resource, version)}
}

func (_c *DataCoordCatalog_SaveFileResource_Call) Run(run func(ctx context.Context, resource *internalpb.FileResourceInfo, version uint64)) *DataCoordCatalog_SaveFileResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*internalpb.FileResourceInfo), args[2].(uint64))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveFileResource_Call) RunAndReturn(run func(context.Context, *internalpb.FileResourceInfo, uint64) error) *DataCoordCatalog_SaveFileResource_Call {
	_c.Call.Return(run)
	return _c
}

// SaveImportJob provides a mock function with given fields: ctx, job
func (_m *DataCoordCatalog) SaveImportJob(ctx context.Context, job *datapb.ImportJob) error {
	ret := _m.Called(ctx, job)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportJob) error); ok {
		r0 = rf(ctx, job)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveImportJob is a helper method to define mock.On call
//   - ctx context.Context
//   - job *datapb.ImportJob
func (_e *DataCoordCatalog_Expecter) SaveImportJob(ctx interface{}, job interface{}) *DataCoordCatalog_SaveImportJob_Call {
	return &DataCoordCatalog_SaveImportJob_Call{Call: _e.mock.On("SaveImportJob", ctx, job)}
}

func (_c *DataCoordCatalog_SaveImportJob_Call) Run(run func(ctx context.Context, job *datapb.ImportJob)) *DataCoordCatalog_SaveImportJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.ImportJob))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveImportJob_Call) RunAndReturn(run func(context.Context, *datapb.ImportJob) error) *DataCoordCatalog_SaveImportJob_Call {
	_c.Call.Return(run)
	return _c
}

// SaveImportTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SaveImportTask(ctx context.Context, task *datapb.ImportTaskV2) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportTaskV2) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveImportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *datapb.ImportTaskV2
func (_e *DataCoordCatalog_Expecter) SaveImportTask(ctx interface{}, task interface{}) *DataCoordCatalog_SaveImportTask_Call {
	return &DataCoordCatalog_SaveImportTask_Call{Call: _e.mock.On("SaveImportTask", ctx, task)}
}

func (_c *DataCoordCatalog_SaveImportTask_Call) Run(run func(ctx context.Context, task *datapb.ImportTaskV2)) *DataCoordCatalog_SaveImportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.ImportTaskV2))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveImportTask_Call) RunAndReturn(run func(context.Context, *datapb.ImportTaskV2) error) *DataCoordCatalog_SaveImportTask_Call {
	_c.Call.Return(run)
	return _c
}

// SavePreImportTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SavePreImportTask(ctx context.Context, task *datapb.PreImportTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.PreImportTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SavePreImportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *datapb.PreImportTask
func (_e *DataCoordCatalog_Expecter) SavePreImportTask(ctx interface{}, task interface{}) *DataCoordCatalog_SavePreImportTask_Call {
	return &DataCoordCatalog_SavePreImportTask_Call{Call: _e.mock.On("SavePreImportTask", ctx, task)}
}

func (_c *DataCoordCatalog_SavePreImportTask_Call) Run(run func(ctx context.Context, task *datapb.PreImportTask)) *DataCoordCatalog_SavePreImportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.PreImportTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SavePreImportTask_Call) RunAndReturn(run func(context.Context, *datapb.PreImportTask) error) *DataCoordCatalog_SavePreImportTask_Call {
	_c.Call.Return(run)
	return _c
}

// SaveSnapshot provides a mock function with given fields: ctx, snapshot
func (_m *DataCoordCatalog) SaveSnapshot(ctx context.Context, snapshot *datapb.SnapshotInfo) error {
	ret := _m.Called(ctx, snapshot)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *datapb.SnapshotInfo) error); ok {
		r0 = rf(ctx, snapshot)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - snapshot *datapb.SnapshotInfo
func (_e *DataCoordCatalog_Expecter) SaveSnapshot(ctx interface{}, snapshot interface{}) *DataCoordCatalog_SaveSnapshot_Call {
	return &DataCoordCatalog_SaveSnapshot_Call{Call: _e.mock.On("SaveSnapshot", ctx, snapshot)}
}

func (_c *DataCoordCatalog_SaveSnapshot_Call) Run(run func(ctx context.Context, snapshot *datapb.SnapshotInfo)) *DataCoordCatalog_SaveSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*datapb.SnapshotInfo))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveSnapshot_Call) RunAndReturn(run func(context.Context, *datapb.SnapshotInfo) error) *DataCoordCatalog_SaveSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// SaveStatsTask provides a mock function with given fields: ctx, task
func (_m *DataCoordCatalog) SaveStatsTask(ctx context.Context, task *indexpb.StatsTask) error {
	ret := _m.Called(ctx, task)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.StatsTask) error); ok {
		r0 = rf(ctx, task)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveStatsTask is a helper method to define mock.On call
//   - ctx context.Context
//   - task *indexpb.StatsTask
func (_e *DataCoordCatalog_Expecter) SaveStatsTask(ctx interface{}, task interface{}) *DataCoordCatalog_SaveStatsTask_Call {
	return &DataCoordCatalog_SaveStatsTask_Call{Call: _e.mock.On("SaveStatsTask", ctx, task)}
}

func (_c *DataCoordCatalog_SaveStatsTask_Call) Run(run func(ctx context.Context, task *indexpb.StatsTask)) *DataCoordCatalog_SaveStatsTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*indexpb.StatsTask))
	})
	return _c
}

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

func (_c *DataCoordCatalog_SaveStatsTask_Call) RunAndReturn(run func(context.Context, *indexpb.StatsTask) error) *DataCoordCatalog_SaveStatsTask_Call {
	_c.Call.Return(run)
	return _c
}

// ShouldDropChannel provides a mock function with given fields: ctx, channel
func (_m *DataCoordCatalog) ShouldDropChannel(ctx context.Context, channel string) bool {
	ret := _m.Called(ctx, channel)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok {
		r0 = rf(ctx, channel)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ShouldDropChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - channel string
func (_e *DataCoordCatalog_Expecter) ShouldDropChannel(ctx interface{}, channel interface{}) *DataCoordCatalog_ShouldDropChannel_Call {
	return &DataCoordCatalog_ShouldDropChannel_Call{Call: _e.mock.On("ShouldDropChannel", ctx, channel)}
}

func (_c *DataCoordCatalog_ShouldDropChannel_Call) Run(run func(ctx context.Context, channel string)) *DataCoordCatalog_ShouldDropChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *DataCoordCatalog_ShouldDropChannel_Call) Return(_a0 bool) *DataCoordCatalog_ShouldDropChannel_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataCoordCatalog_ShouldDropChannel_Call) RunAndReturn(run func(context.Context, string) bool) *DataCoordCatalog_ShouldDropChannel_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: ctx, actions
func (_m *DataCoordCatalog) Update(ctx context.Context, actions ...metastore.UpdateAction) error {
	_va := make([]interface{}, len(actions))
	for _i := range actions {
		_va[_i] = actions[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ...metastore.UpdateAction) error); ok {
		r0 = rf(ctx, actions...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - actions ...metastore.UpdateAction
func (_e *DataCoordCatalog_Expecter) Update(ctx interface{}, actions ...interface{}) *DataCoordCatalog_Update_Call {
	return &DataCoordCatalog_Update_Call{Call: _e.mock.On("Update",
		append([]interface{}{ctx}, actions...)...)}
}

func (_c *DataCoordCatalog_Update_Call) Run(run func(ctx context.Context, actions ...metastore.UpdateAction)) *DataCoordCatalog_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]metastore.UpdateAction, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(metastore.UpdateAction)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

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

func (_c *DataCoordCatalog_Update_Call) RunAndReturn(run func(context.Context, ...metastore.UpdateAction) error) *DataCoordCatalog_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
