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

package mocks

import (
	context "context"

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

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

	model "github.com/milvus-io/milvus/internal/metastore/model"
)

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

type RootCoordCatalog_Expecter struct {
	mock *mock.Mock
}

func (_m *RootCoordCatalog) EXPECT() *RootCoordCatalog_Expecter {
	return &RootCoordCatalog_Expecter{mock: &_m.Mock}
}

// AlterAlias provides a mock function with given fields: ctx, alias, ts
func (_m *RootCoordCatalog) AlterAlias(ctx context.Context, alias *model.Alias, ts uint64) error {
	ret := _m.Called(ctx, alias, ts)

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

	return r0
}

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

// AlterAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - alias *model.Alias
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) AlterAlias(ctx interface{}, alias interface{}, ts interface{}) *RootCoordCatalog_AlterAlias_Call {
	return &RootCoordCatalog_AlterAlias_Call{Call: _e.mock.On("AlterAlias", ctx, alias, ts)}
}

func (_c *RootCoordCatalog_AlterAlias_Call) Run(run func(ctx context.Context, alias *model.Alias, ts uint64)) *RootCoordCatalog_AlterAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Alias), args[2].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_AlterAlias_Call) RunAndReturn(run func(context.Context, *model.Alias, uint64) error) *RootCoordCatalog_AlterAlias_Call {
	_c.Call.Return(run)
	return _c
}

// AlterCollection provides a mock function with given fields: ctx, oldColl, newColl, alterType, ts
func (_m *RootCoordCatalog) AlterCollection(ctx context.Context, oldColl *model.Collection, newColl *model.Collection, alterType metastore.AlterType, ts uint64) error {
	ret := _m.Called(ctx, oldColl, newColl, alterType, ts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *model.Collection, *model.Collection, metastore.AlterType, uint64) error); ok {
		r0 = rf(ctx, oldColl, newColl, alterType, ts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - oldColl *model.Collection
//   - newColl *model.Collection
//   - alterType metastore.AlterType
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) AlterCollection(ctx interface{}, oldColl interface{}, newColl interface{}, alterType interface{}, ts interface{}) *RootCoordCatalog_AlterCollection_Call {
	return &RootCoordCatalog_AlterCollection_Call{Call: _e.mock.On("AlterCollection", ctx, oldColl, newColl, alterType, ts)}
}

func (_c *RootCoordCatalog_AlterCollection_Call) Run(run func(ctx context.Context, oldColl *model.Collection, newColl *model.Collection, alterType metastore.AlterType, ts uint64)) *RootCoordCatalog_AlterCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Collection), args[2].(*model.Collection), args[3].(metastore.AlterType), args[4].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_AlterCollection_Call) RunAndReturn(run func(context.Context, *model.Collection, *model.Collection, metastore.AlterType, uint64) error) *RootCoordCatalog_AlterCollection_Call {
	_c.Call.Return(run)
	return _c
}

// AlterCredential provides a mock function with given fields: ctx, credential
func (_m *RootCoordCatalog) AlterCredential(ctx context.Context, credential *model.Credential) error {
	ret := _m.Called(ctx, credential)

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

	return r0
}

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

// AlterCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - credential *model.Credential
func (_e *RootCoordCatalog_Expecter) AlterCredential(ctx interface{}, credential interface{}) *RootCoordCatalog_AlterCredential_Call {
	return &RootCoordCatalog_AlterCredential_Call{Call: _e.mock.On("AlterCredential", ctx, credential)}
}

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

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

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

// AlterDatabase provides a mock function with given fields: ctx, newDB, ts
func (_m *RootCoordCatalog) AlterDatabase(ctx context.Context, newDB *model.Database, ts uint64) error {
	ret := _m.Called(ctx, newDB, ts)

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

	return r0
}

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

// AlterDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - newDB *model.Database
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) AlterDatabase(ctx interface{}, newDB interface{}, ts interface{}) *RootCoordCatalog_AlterDatabase_Call {
	return &RootCoordCatalog_AlterDatabase_Call{Call: _e.mock.On("AlterDatabase", ctx, newDB, ts)}
}

func (_c *RootCoordCatalog_AlterDatabase_Call) Run(run func(ctx context.Context, newDB *model.Database, ts uint64)) *RootCoordCatalog_AlterDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Database), args[2].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_AlterDatabase_Call) RunAndReturn(run func(context.Context, *model.Database, uint64) error) *RootCoordCatalog_AlterDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// AlterGrant provides a mock function with given fields: ctx, tenant, entity, operateType
func (_m *RootCoordCatalog) AlterGrant(ctx context.Context, tenant string, entity *milvuspb.GrantEntity, operateType milvuspb.OperatePrivilegeType) error {
	ret := _m.Called(ctx, tenant, entity, operateType)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *milvuspb.GrantEntity, milvuspb.OperatePrivilegeType) error); ok {
		r0 = rf(ctx, tenant, entity, operateType)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterGrant is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - entity *milvuspb.GrantEntity
//   - operateType milvuspb.OperatePrivilegeType
func (_e *RootCoordCatalog_Expecter) AlterGrant(ctx interface{}, tenant interface{}, entity interface{}, operateType interface{}) *RootCoordCatalog_AlterGrant_Call {
	return &RootCoordCatalog_AlterGrant_Call{Call: _e.mock.On("AlterGrant", ctx, tenant, entity, operateType)}
}

func (_c *RootCoordCatalog_AlterGrant_Call) Run(run func(ctx context.Context, tenant string, entity *milvuspb.GrantEntity, operateType milvuspb.OperatePrivilegeType)) *RootCoordCatalog_AlterGrant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.GrantEntity), args[3].(milvuspb.OperatePrivilegeType))
	})
	return _c
}

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

func (_c *RootCoordCatalog_AlterGrant_Call) RunAndReturn(run func(context.Context, string, *milvuspb.GrantEntity, milvuspb.OperatePrivilegeType) error) *RootCoordCatalog_AlterGrant_Call {
	_c.Call.Return(run)
	return _c
}

// AlterPartition provides a mock function with given fields: ctx, dbID, oldPart, newPart, alterType, ts
func (_m *RootCoordCatalog) AlterPartition(ctx context.Context, dbID int64, oldPart *model.Partition, newPart *model.Partition, alterType metastore.AlterType, ts uint64) error {
	ret := _m.Called(ctx, dbID, oldPart, newPart, alterType, ts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, *model.Partition, *model.Partition, metastore.AlterType, uint64) error); ok {
		r0 = rf(ctx, dbID, oldPart, newPart, alterType, ts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterPartition is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - oldPart *model.Partition
//   - newPart *model.Partition
//   - alterType metastore.AlterType
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) AlterPartition(ctx interface{}, dbID interface{}, oldPart interface{}, newPart interface{}, alterType interface{}, ts interface{}) *RootCoordCatalog_AlterPartition_Call {
	return &RootCoordCatalog_AlterPartition_Call{Call: _e.mock.On("AlterPartition", ctx, dbID, oldPart, newPart, alterType, ts)}
}

func (_c *RootCoordCatalog_AlterPartition_Call) Run(run func(ctx context.Context, dbID int64, oldPart *model.Partition, newPart *model.Partition, alterType metastore.AlterType, ts uint64)) *RootCoordCatalog_AlterPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(*model.Partition), args[3].(*model.Partition), args[4].(metastore.AlterType), args[5].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_AlterPartition_Call) RunAndReturn(run func(context.Context, int64, *model.Partition, *model.Partition, metastore.AlterType, uint64) error) *RootCoordCatalog_AlterPartition_Call {
	_c.Call.Return(run)
	return _c
}

// AlterUserRole provides a mock function with given fields: ctx, tenant, userEntity, roleEntity, operateType
func (_m *RootCoordCatalog) AlterUserRole(ctx context.Context, tenant string, userEntity *milvuspb.UserEntity, roleEntity *milvuspb.RoleEntity, operateType milvuspb.OperateUserRoleType) error {
	ret := _m.Called(ctx, tenant, userEntity, roleEntity, operateType)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *milvuspb.UserEntity, *milvuspb.RoleEntity, milvuspb.OperateUserRoleType) error); ok {
		r0 = rf(ctx, tenant, userEntity, roleEntity, operateType)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AlterUserRole is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - userEntity *milvuspb.UserEntity
//   - roleEntity *milvuspb.RoleEntity
//   - operateType milvuspb.OperateUserRoleType
func (_e *RootCoordCatalog_Expecter) AlterUserRole(ctx interface{}, tenant interface{}, userEntity interface{}, roleEntity interface{}, operateType interface{}) *RootCoordCatalog_AlterUserRole_Call {
	return &RootCoordCatalog_AlterUserRole_Call{Call: _e.mock.On("AlterUserRole", ctx, tenant, userEntity, roleEntity, operateType)}
}

func (_c *RootCoordCatalog_AlterUserRole_Call) Run(run func(ctx context.Context, tenant string, userEntity *milvuspb.UserEntity, roleEntity *milvuspb.RoleEntity, operateType milvuspb.OperateUserRoleType)) *RootCoordCatalog_AlterUserRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.UserEntity), args[3].(*milvuspb.RoleEntity), args[4].(milvuspb.OperateUserRoleType))
	})
	return _c
}

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

func (_c *RootCoordCatalog_AlterUserRole_Call) RunAndReturn(run func(context.Context, string, *milvuspb.UserEntity, *milvuspb.RoleEntity, milvuspb.OperateUserRoleType) error) *RootCoordCatalog_AlterUserRole_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function with given fields:
func (_m *RootCoordCatalog) Close() {
	_m.Called()
}

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

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

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

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

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

// CollectionExists provides a mock function with given fields: ctx, dbID, collectionID, ts
func (_m *RootCoordCatalog) CollectionExists(ctx context.Context, dbID int64, collectionID int64, ts uint64) bool {
	ret := _m.Called(ctx, dbID, collectionID, ts)

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

	return r0
}

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

// CollectionExists is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - collectionID int64
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) CollectionExists(ctx interface{}, dbID interface{}, collectionID interface{}, ts interface{}) *RootCoordCatalog_CollectionExists_Call {
	return &RootCoordCatalog_CollectionExists_Call{Call: _e.mock.On("CollectionExists", ctx, dbID, collectionID, ts)}
}

func (_c *RootCoordCatalog_CollectionExists_Call) Run(run func(ctx context.Context, dbID int64, collectionID int64, ts uint64)) *RootCoordCatalog_CollectionExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(uint64))
	})
	return _c
}

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

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

// CreateAlias provides a mock function with given fields: ctx, alias, ts
func (_m *RootCoordCatalog) CreateAlias(ctx context.Context, alias *model.Alias, ts uint64) error {
	ret := _m.Called(ctx, alias, ts)

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

	return r0
}

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

// CreateAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - alias *model.Alias
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) CreateAlias(ctx interface{}, alias interface{}, ts interface{}) *RootCoordCatalog_CreateAlias_Call {
	return &RootCoordCatalog_CreateAlias_Call{Call: _e.mock.On("CreateAlias", ctx, alias, ts)}
}

func (_c *RootCoordCatalog_CreateAlias_Call) Run(run func(ctx context.Context, alias *model.Alias, ts uint64)) *RootCoordCatalog_CreateAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Alias), args[2].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_CreateAlias_Call) RunAndReturn(run func(context.Context, *model.Alias, uint64) error) *RootCoordCatalog_CreateAlias_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCollection provides a mock function with given fields: ctx, collectionInfo, ts
func (_m *RootCoordCatalog) CreateCollection(ctx context.Context, collectionInfo *model.Collection, ts uint64) error {
	ret := _m.Called(ctx, collectionInfo, ts)

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

	return r0
}

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

// CreateCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - collectionInfo *model.Collection
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) CreateCollection(ctx interface{}, collectionInfo interface{}, ts interface{}) *RootCoordCatalog_CreateCollection_Call {
	return &RootCoordCatalog_CreateCollection_Call{Call: _e.mock.On("CreateCollection", ctx, collectionInfo, ts)}
}

func (_c *RootCoordCatalog_CreateCollection_Call) Run(run func(ctx context.Context, collectionInfo *model.Collection, ts uint64)) *RootCoordCatalog_CreateCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Collection), args[2].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_CreateCollection_Call) RunAndReturn(run func(context.Context, *model.Collection, uint64) error) *RootCoordCatalog_CreateCollection_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCredential provides a mock function with given fields: ctx, credential
func (_m *RootCoordCatalog) CreateCredential(ctx context.Context, credential *model.Credential) error {
	ret := _m.Called(ctx, credential)

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

	return r0
}

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

// CreateCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - credential *model.Credential
func (_e *RootCoordCatalog_Expecter) CreateCredential(ctx interface{}, credential interface{}) *RootCoordCatalog_CreateCredential_Call {
	return &RootCoordCatalog_CreateCredential_Call{Call: _e.mock.On("CreateCredential", ctx, credential)}
}

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

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

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

// CreateDatabase provides a mock function with given fields: ctx, db, ts
func (_m *RootCoordCatalog) CreateDatabase(ctx context.Context, db *model.Database, ts uint64) error {
	ret := _m.Called(ctx, db, ts)

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

	return r0
}

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

// CreateDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - db *model.Database
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) CreateDatabase(ctx interface{}, db interface{}, ts interface{}) *RootCoordCatalog_CreateDatabase_Call {
	return &RootCoordCatalog_CreateDatabase_Call{Call: _e.mock.On("CreateDatabase", ctx, db, ts)}
}

func (_c *RootCoordCatalog_CreateDatabase_Call) Run(run func(ctx context.Context, db *model.Database, ts uint64)) *RootCoordCatalog_CreateDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Database), args[2].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_CreateDatabase_Call) RunAndReturn(run func(context.Context, *model.Database, uint64) error) *RootCoordCatalog_CreateDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePartition provides a mock function with given fields: ctx, dbID, partition, ts
func (_m *RootCoordCatalog) CreatePartition(ctx context.Context, dbID int64, partition *model.Partition, ts uint64) error {
	ret := _m.Called(ctx, dbID, partition, ts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, *model.Partition, uint64) error); ok {
		r0 = rf(ctx, dbID, partition, ts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreatePartition is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - partition *model.Partition
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) CreatePartition(ctx interface{}, dbID interface{}, partition interface{}, ts interface{}) *RootCoordCatalog_CreatePartition_Call {
	return &RootCoordCatalog_CreatePartition_Call{Call: _e.mock.On("CreatePartition", ctx, dbID, partition, ts)}
}

func (_c *RootCoordCatalog_CreatePartition_Call) Run(run func(ctx context.Context, dbID int64, partition *model.Partition, ts uint64)) *RootCoordCatalog_CreatePartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(*model.Partition), args[3].(uint64))
	})
	return _c
}

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

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

// CreateRole provides a mock function with given fields: ctx, tenant, entity
func (_m *RootCoordCatalog) CreateRole(ctx context.Context, tenant string, entity *milvuspb.RoleEntity) error {
	ret := _m.Called(ctx, tenant, entity)

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

	return r0
}

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

// CreateRole is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - entity *milvuspb.RoleEntity
func (_e *RootCoordCatalog_Expecter) CreateRole(ctx interface{}, tenant interface{}, entity interface{}) *RootCoordCatalog_CreateRole_Call {
	return &RootCoordCatalog_CreateRole_Call{Call: _e.mock.On("CreateRole", ctx, tenant, entity)}
}

func (_c *RootCoordCatalog_CreateRole_Call) Run(run func(ctx context.Context, tenant string, entity *milvuspb.RoleEntity)) *RootCoordCatalog_CreateRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.RoleEntity))
	})
	return _c
}

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

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

// DeleteGrant provides a mock function with given fields: ctx, tenant, role
func (_m *RootCoordCatalog) DeleteGrant(ctx context.Context, tenant string, role *milvuspb.RoleEntity) error {
	ret := _m.Called(ctx, tenant, role)

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

	return r0
}

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

// DeleteGrant is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - role *milvuspb.RoleEntity
func (_e *RootCoordCatalog_Expecter) DeleteGrant(ctx interface{}, tenant interface{}, role interface{}) *RootCoordCatalog_DeleteGrant_Call {
	return &RootCoordCatalog_DeleteGrant_Call{Call: _e.mock.On("DeleteGrant", ctx, tenant, role)}
}

func (_c *RootCoordCatalog_DeleteGrant_Call) Run(run func(ctx context.Context, tenant string, role *milvuspb.RoleEntity)) *RootCoordCatalog_DeleteGrant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.RoleEntity))
	})
	return _c
}

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

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

// DropAlias provides a mock function with given fields: ctx, dbID, alias, ts
func (_m *RootCoordCatalog) DropAlias(ctx context.Context, dbID int64, alias string, ts uint64) error {
	ret := _m.Called(ctx, dbID, alias, ts)

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

	return r0
}

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

// DropAlias is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - alias string
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) DropAlias(ctx interface{}, dbID interface{}, alias interface{}, ts interface{}) *RootCoordCatalog_DropAlias_Call {
	return &RootCoordCatalog_DropAlias_Call{Call: _e.mock.On("DropAlias", ctx, dbID, alias, ts)}
}

func (_c *RootCoordCatalog_DropAlias_Call) Run(run func(ctx context.Context, dbID int64, alias string, ts uint64)) *RootCoordCatalog_DropAlias_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(uint64))
	})
	return _c
}

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

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

// DropCollection provides a mock function with given fields: ctx, collectionInfo, ts
func (_m *RootCoordCatalog) DropCollection(ctx context.Context, collectionInfo *model.Collection, ts uint64) error {
	ret := _m.Called(ctx, collectionInfo, ts)

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

	return r0
}

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

// DropCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - collectionInfo *model.Collection
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) DropCollection(ctx interface{}, collectionInfo interface{}, ts interface{}) *RootCoordCatalog_DropCollection_Call {
	return &RootCoordCatalog_DropCollection_Call{Call: _e.mock.On("DropCollection", ctx, collectionInfo, ts)}
}

func (_c *RootCoordCatalog_DropCollection_Call) Run(run func(ctx context.Context, collectionInfo *model.Collection, ts uint64)) *RootCoordCatalog_DropCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*model.Collection), args[2].(uint64))
	})
	return _c
}

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

func (_c *RootCoordCatalog_DropCollection_Call) RunAndReturn(run func(context.Context, *model.Collection, uint64) error) *RootCoordCatalog_DropCollection_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return r0
}

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

// DropCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - username string
func (_e *RootCoordCatalog_Expecter) DropCredential(ctx interface{}, username interface{}) *RootCoordCatalog_DropCredential_Call {
	return &RootCoordCatalog_DropCredential_Call{Call: _e.mock.On("DropCredential", ctx, username)}
}

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

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

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

// DropDatabase provides a mock function with given fields: ctx, dbID, ts
func (_m *RootCoordCatalog) DropDatabase(ctx context.Context, dbID int64, ts uint64) error {
	ret := _m.Called(ctx, dbID, ts)

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

	return r0
}

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

// DropDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) DropDatabase(ctx interface{}, dbID interface{}, ts interface{}) *RootCoordCatalog_DropDatabase_Call {
	return &RootCoordCatalog_DropDatabase_Call{Call: _e.mock.On("DropDatabase", ctx, dbID, ts)}
}

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

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

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

// DropPartition provides a mock function with given fields: ctx, dbID, collectionID, partitionID, ts
func (_m *RootCoordCatalog) DropPartition(ctx context.Context, dbID int64, collectionID int64, partitionID int64, ts uint64) error {
	ret := _m.Called(ctx, dbID, collectionID, partitionID, ts)

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

	return r0
}

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

// DropPartition is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - collectionID int64
//   - partitionID int64
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) DropPartition(ctx interface{}, dbID interface{}, collectionID interface{}, partitionID interface{}, ts interface{}) *RootCoordCatalog_DropPartition_Call {
	return &RootCoordCatalog_DropPartition_Call{Call: _e.mock.On("DropPartition", ctx, dbID, collectionID, partitionID, ts)}
}

func (_c *RootCoordCatalog_DropPartition_Call) Run(run func(ctx context.Context, dbID int64, collectionID int64, partitionID int64, ts uint64)) *RootCoordCatalog_DropPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(int64), args[4].(uint64))
	})
	return _c
}

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

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

// DropRole provides a mock function with given fields: ctx, tenant, roleName
func (_m *RootCoordCatalog) DropRole(ctx context.Context, tenant string, roleName string) error {
	ret := _m.Called(ctx, tenant, roleName)

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

	return r0
}

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

// DropRole is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - roleName string
func (_e *RootCoordCatalog_Expecter) DropRole(ctx interface{}, tenant interface{}, roleName interface{}) *RootCoordCatalog_DropRole_Call {
	return &RootCoordCatalog_DropRole_Call{Call: _e.mock.On("DropRole", ctx, tenant, roleName)}
}

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

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

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

// GetCollectionByID provides a mock function with given fields: ctx, dbID, ts, collectionID
func (_m *RootCoordCatalog) GetCollectionByID(ctx context.Context, dbID int64, ts uint64, collectionID int64) (*model.Collection, error) {
	ret := _m.Called(ctx, dbID, ts, collectionID)

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

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

	return r0, r1
}

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

// GetCollectionByID is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - ts uint64
//   - collectionID int64
func (_e *RootCoordCatalog_Expecter) GetCollectionByID(ctx interface{}, dbID interface{}, ts interface{}, collectionID interface{}) *RootCoordCatalog_GetCollectionByID_Call {
	return &RootCoordCatalog_GetCollectionByID_Call{Call: _e.mock.On("GetCollectionByID", ctx, dbID, ts, collectionID)}
}

func (_c *RootCoordCatalog_GetCollectionByID_Call) Run(run func(ctx context.Context, dbID int64, ts uint64, collectionID int64)) *RootCoordCatalog_GetCollectionByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(uint64), args[3].(int64))
	})
	return _c
}

func (_c *RootCoordCatalog_GetCollectionByID_Call) Return(_a0 *model.Collection, _a1 error) *RootCoordCatalog_GetCollectionByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetCollectionByName provides a mock function with given fields: ctx, dbID, collectionName, ts
func (_m *RootCoordCatalog) GetCollectionByName(ctx context.Context, dbID int64, collectionName string, ts uint64) (*model.Collection, error) {
	ret := _m.Called(ctx, dbID, collectionName, ts)

	var r0 *model.Collection
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string, uint64) (*model.Collection, error)); ok {
		return rf(ctx, dbID, collectionName, ts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, string, uint64) *model.Collection); ok {
		r0 = rf(ctx, dbID, collectionName, ts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Collection)
		}
	}

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

	return r0, r1
}

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

// GetCollectionByName is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - collectionName string
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) GetCollectionByName(ctx interface{}, dbID interface{}, collectionName interface{}, ts interface{}) *RootCoordCatalog_GetCollectionByName_Call {
	return &RootCoordCatalog_GetCollectionByName_Call{Call: _e.mock.On("GetCollectionByName", ctx, dbID, collectionName, ts)}
}

func (_c *RootCoordCatalog_GetCollectionByName_Call) Run(run func(ctx context.Context, dbID int64, collectionName string, ts uint64)) *RootCoordCatalog_GetCollectionByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(uint64))
	})
	return _c
}

func (_c *RootCoordCatalog_GetCollectionByName_Call) Return(_a0 *model.Collection, _a1 error) *RootCoordCatalog_GetCollectionByName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *RootCoordCatalog_GetCollectionByName_Call) RunAndReturn(run func(context.Context, int64, string, uint64) (*model.Collection, error)) *RootCoordCatalog_GetCollectionByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetCredential provides a mock function with given fields: ctx, username
func (_m *RootCoordCatalog) GetCredential(ctx context.Context, username string) (*model.Credential, error) {
	ret := _m.Called(ctx, username)

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

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

	return r0, r1
}

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

// GetCredential is a helper method to define mock.On call
//   - ctx context.Context
//   - username string
func (_e *RootCoordCatalog_Expecter) GetCredential(ctx interface{}, username interface{}) *RootCoordCatalog_GetCredential_Call {
	return &RootCoordCatalog_GetCredential_Call{Call: _e.mock.On("GetCredential", ctx, username)}
}

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

func (_c *RootCoordCatalog_GetCredential_Call) Return(_a0 *model.Credential, _a1 error) *RootCoordCatalog_GetCredential_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ListAliases provides a mock function with given fields: ctx, dbID, ts
func (_m *RootCoordCatalog) ListAliases(ctx context.Context, dbID int64, ts uint64) ([]*model.Alias, error) {
	ret := _m.Called(ctx, dbID, ts)

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

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

	return r0, r1
}

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

// ListAliases is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) ListAliases(ctx interface{}, dbID interface{}, ts interface{}) *RootCoordCatalog_ListAliases_Call {
	return &RootCoordCatalog_ListAliases_Call{Call: _e.mock.On("ListAliases", ctx, dbID, ts)}
}

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

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

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

// ListCollections provides a mock function with given fields: ctx, dbID, ts
func (_m *RootCoordCatalog) ListCollections(ctx context.Context, dbID int64, ts uint64) ([]*model.Collection, error) {
	ret := _m.Called(ctx, dbID, ts)

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

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

	return r0, r1
}

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

// ListCollections is a helper method to define mock.On call
//   - ctx context.Context
//   - dbID int64
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) ListCollections(ctx interface{}, dbID interface{}, ts interface{}) *RootCoordCatalog_ListCollections_Call {
	return &RootCoordCatalog_ListCollections_Call{Call: _e.mock.On("ListCollections", ctx, dbID, ts)}
}

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

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

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

// ListCredentials provides a mock function with given fields: ctx
func (_m *RootCoordCatalog) ListCredentials(ctx context.Context) ([]string, error) {
	ret := _m.Called(ctx)

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

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

	return r0, r1
}

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

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

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

func (_c *RootCoordCatalog_ListCredentials_Call) Return(_a0 []string, _a1 error) *RootCoordCatalog_ListCredentials_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ListDatabases provides a mock function with given fields: ctx, ts
func (_m *RootCoordCatalog) ListDatabases(ctx context.Context, ts uint64) ([]*model.Database, error) {
	ret := _m.Called(ctx, ts)

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

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

	return r0, r1
}

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

// ListDatabases is a helper method to define mock.On call
//   - ctx context.Context
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) ListDatabases(ctx interface{}, ts interface{}) *RootCoordCatalog_ListDatabases_Call {
	return &RootCoordCatalog_ListDatabases_Call{Call: _e.mock.On("ListDatabases", ctx, ts)}
}

func (_c *RootCoordCatalog_ListDatabases_Call) Run(run func(ctx context.Context, ts uint64)) *RootCoordCatalog_ListDatabases_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64))
	})
	return _c
}

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

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

// ListGrant provides a mock function with given fields: ctx, tenant, entity
func (_m *RootCoordCatalog) ListGrant(ctx context.Context, tenant string, entity *milvuspb.GrantEntity) ([]*milvuspb.GrantEntity, error) {
	ret := _m.Called(ctx, tenant, entity)

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

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

	return r0, r1
}

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

// ListGrant is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - entity *milvuspb.GrantEntity
func (_e *RootCoordCatalog_Expecter) ListGrant(ctx interface{}, tenant interface{}, entity interface{}) *RootCoordCatalog_ListGrant_Call {
	return &RootCoordCatalog_ListGrant_Call{Call: _e.mock.On("ListGrant", ctx, tenant, entity)}
}

func (_c *RootCoordCatalog_ListGrant_Call) Run(run func(ctx context.Context, tenant string, entity *milvuspb.GrantEntity)) *RootCoordCatalog_ListGrant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.GrantEntity))
	})
	return _c
}

func (_c *RootCoordCatalog_ListGrant_Call) Return(_a0 []*milvuspb.GrantEntity, _a1 error) *RootCoordCatalog_ListGrant_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *RootCoordCatalog_ListGrant_Call) RunAndReturn(run func(context.Context, string, *milvuspb.GrantEntity) ([]*milvuspb.GrantEntity, error)) *RootCoordCatalog_ListGrant_Call {
	_c.Call.Return(run)
	return _c
}

// ListPolicy provides a mock function with given fields: ctx, tenant
func (_m *RootCoordCatalog) ListPolicy(ctx context.Context, tenant string) ([]string, error) {
	ret := _m.Called(ctx, tenant)

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

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

	return r0, r1
}

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

// ListPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
func (_e *RootCoordCatalog_Expecter) ListPolicy(ctx interface{}, tenant interface{}) *RootCoordCatalog_ListPolicy_Call {
	return &RootCoordCatalog_ListPolicy_Call{Call: _e.mock.On("ListPolicy", ctx, tenant)}
}

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

func (_c *RootCoordCatalog_ListPolicy_Call) Return(_a0 []string, _a1 error) *RootCoordCatalog_ListPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ListRole provides a mock function with given fields: ctx, tenant, entity, includeUserInfo
func (_m *RootCoordCatalog) ListRole(ctx context.Context, tenant string, entity *milvuspb.RoleEntity, includeUserInfo bool) ([]*milvuspb.RoleResult, error) {
	ret := _m.Called(ctx, tenant, entity, includeUserInfo)

	var r0 []*milvuspb.RoleResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *milvuspb.RoleEntity, bool) ([]*milvuspb.RoleResult, error)); ok {
		return rf(ctx, tenant, entity, includeUserInfo)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *milvuspb.RoleEntity, bool) []*milvuspb.RoleResult); ok {
		r0 = rf(ctx, tenant, entity, includeUserInfo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*milvuspb.RoleResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *milvuspb.RoleEntity, bool) error); ok {
		r1 = rf(ctx, tenant, entity, includeUserInfo)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListRole is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - entity *milvuspb.RoleEntity
//   - includeUserInfo bool
func (_e *RootCoordCatalog_Expecter) ListRole(ctx interface{}, tenant interface{}, entity interface{}, includeUserInfo interface{}) *RootCoordCatalog_ListRole_Call {
	return &RootCoordCatalog_ListRole_Call{Call: _e.mock.On("ListRole", ctx, tenant, entity, includeUserInfo)}
}

func (_c *RootCoordCatalog_ListRole_Call) Run(run func(ctx context.Context, tenant string, entity *milvuspb.RoleEntity, includeUserInfo bool)) *RootCoordCatalog_ListRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.RoleEntity), args[3].(bool))
	})
	return _c
}

func (_c *RootCoordCatalog_ListRole_Call) Return(_a0 []*milvuspb.RoleResult, _a1 error) *RootCoordCatalog_ListRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *RootCoordCatalog_ListRole_Call) RunAndReturn(run func(context.Context, string, *milvuspb.RoleEntity, bool) ([]*milvuspb.RoleResult, error)) *RootCoordCatalog_ListRole_Call {
	_c.Call.Return(run)
	return _c
}

// ListUser provides a mock function with given fields: ctx, tenant, entity, includeRoleInfo
func (_m *RootCoordCatalog) ListUser(ctx context.Context, tenant string, entity *milvuspb.UserEntity, includeRoleInfo bool) ([]*milvuspb.UserResult, error) {
	ret := _m.Called(ctx, tenant, entity, includeRoleInfo)

	var r0 []*milvuspb.UserResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *milvuspb.UserEntity, bool) ([]*milvuspb.UserResult, error)); ok {
		return rf(ctx, tenant, entity, includeRoleInfo)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *milvuspb.UserEntity, bool) []*milvuspb.UserResult); ok {
		r0 = rf(ctx, tenant, entity, includeRoleInfo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*milvuspb.UserResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *milvuspb.UserEntity, bool) error); ok {
		r1 = rf(ctx, tenant, entity, includeRoleInfo)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListUser is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
//   - entity *milvuspb.UserEntity
//   - includeRoleInfo bool
func (_e *RootCoordCatalog_Expecter) ListUser(ctx interface{}, tenant interface{}, entity interface{}, includeRoleInfo interface{}) *RootCoordCatalog_ListUser_Call {
	return &RootCoordCatalog_ListUser_Call{Call: _e.mock.On("ListUser", ctx, tenant, entity, includeRoleInfo)}
}

func (_c *RootCoordCatalog_ListUser_Call) Run(run func(ctx context.Context, tenant string, entity *milvuspb.UserEntity, includeRoleInfo bool)) *RootCoordCatalog_ListUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*milvuspb.UserEntity), args[3].(bool))
	})
	return _c
}

func (_c *RootCoordCatalog_ListUser_Call) Return(_a0 []*milvuspb.UserResult, _a1 error) *RootCoordCatalog_ListUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *RootCoordCatalog_ListUser_Call) RunAndReturn(run func(context.Context, string, *milvuspb.UserEntity, bool) ([]*milvuspb.UserResult, error)) *RootCoordCatalog_ListUser_Call {
	_c.Call.Return(run)
	return _c
}

// ListUserRole provides a mock function with given fields: ctx, tenant
func (_m *RootCoordCatalog) ListUserRole(ctx context.Context, tenant string) ([]string, error) {
	ret := _m.Called(ctx, tenant)

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

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

	return r0, r1
}

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

// ListUserRole is a helper method to define mock.On call
//   - ctx context.Context
//   - tenant string
func (_e *RootCoordCatalog_Expecter) ListUserRole(ctx interface{}, tenant interface{}) *RootCoordCatalog_ListUserRole_Call {
	return &RootCoordCatalog_ListUserRole_Call{Call: _e.mock.On("ListUserRole", ctx, tenant)}
}

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

func (_c *RootCoordCatalog_ListUserRole_Call) Return(_a0 []string, _a1 error) *RootCoordCatalog_ListUserRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	return mock
}
