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

package mocks

import (
	context "context"

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

// 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)

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

	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, fieldModify
func (_m *RootCoordCatalog) AlterCollection(ctx context.Context, oldColl *model.Collection, newColl *model.Collection, alterType metastore.AlterType, ts uint64, fieldModify bool) error {
	ret := _m.Called(ctx, oldColl, newColl, alterType, ts, fieldModify)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *model.Collection, *model.Collection, metastore.AlterType, uint64, bool) error); ok {
		r0 = rf(ctx, oldColl, newColl, alterType, ts, fieldModify)
	} 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
//   - fieldModify bool
func (_e *RootCoordCatalog_Expecter) AlterCollection(ctx interface{}, oldColl interface{}, newColl interface{}, alterType interface{}, ts interface{}, fieldModify interface{}) *RootCoordCatalog_AlterCollection_Call {
	return &RootCoordCatalog_AlterCollection_Call{Call: _e.mock.On("AlterCollection", ctx, oldColl, newColl, alterType, ts, fieldModify)}
}

func (_c *RootCoordCatalog_AlterCollection_Call) Run(run func(ctx context.Context, oldColl *model.Collection, newColl *model.Collection, alterType metastore.AlterType, ts uint64, fieldModify bool)) *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), args[5].(bool))
	})
	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, bool) error) *RootCoordCatalog_AlterCollection_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

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

func (_c *RootCoordCatalog_AlterCollectionDB_Call) RunAndReturn(run func(context.Context, *model.Collection, *model.Collection, uint64) error) *RootCoordCatalog_AlterCollectionDB_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)

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

	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)

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

	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)

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

	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)

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

	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
}

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

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

	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_AlterRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterRole'
type RootCoordCatalog_AlterRole_Call struct {
	*mock.Call
}

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

func (_c *RootCoordCatalog_AlterRole_Call) Run(run func(ctx context.Context, tenant string, entity *milvuspb.RoleEntity)) *RootCoordCatalog_AlterRole_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_AlterRole_Call) Return(_a0 error) *RootCoordCatalog_AlterRole_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *RootCoordCatalog_AlterRole_Call) RunAndReturn(run func(context.Context, string, *milvuspb.RoleEntity) error) *RootCoordCatalog_AlterRole_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)

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

	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
}

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

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

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

	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_BackupRBAC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BackupRBAC'
type RootCoordCatalog_BackupRBAC_Call struct {
	*mock.Call
}

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

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

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

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

// Close provides a mock function with no 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.Run(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)

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

	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)

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

	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)

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

	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
}

// 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)

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

	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)

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

	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)

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

	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)

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

	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
}

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

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

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

	return r0
}

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

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

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

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

func (_c *RootCoordCatalog_DeleteGrantByCollectionName_Call) RunAndReturn(run func(context.Context, string, string, string) error) *RootCoordCatalog_DeleteGrantByCollectionName_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)

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

	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)

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

	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)

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

	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)

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

	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)

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

	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
}

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

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

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

	return r0
}

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

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

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

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

func (_c *RootCoordCatalog_DropPrivilegeGroup_Call) RunAndReturn(run func(context.Context, string) error) *RootCoordCatalog_DropPrivilegeGroup_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)

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

	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)

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

	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, dbName, collectionName, ts
func (_m *RootCoordCatalog) GetCollectionByName(ctx context.Context, dbID int64, dbName string, collectionName string, ts uint64) (*model.Collection, error) {
	ret := _m.Called(ctx, dbID, dbName, collectionName, ts)

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

	var r0 *model.Collection
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string, string, uint64) (*model.Collection, error)); ok {
		return rf(ctx, dbID, dbName, collectionName, ts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, string, string, uint64) *model.Collection); ok {
		r0 = rf(ctx, dbID, dbName, 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, string, uint64) error); ok {
		r1 = rf(ctx, dbID, dbName, 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
//   - dbName string
//   - collectionName string
//   - ts uint64
func (_e *RootCoordCatalog_Expecter) GetCollectionByName(ctx interface{}, dbID interface{}, dbName interface{}, collectionName interface{}, ts interface{}) *RootCoordCatalog_GetCollectionByName_Call {
	return &RootCoordCatalog_GetCollectionByName_Call{Call: _e.mock.On("GetCollectionByName", ctx, dbID, dbName, collectionName, ts)}
}

func (_c *RootCoordCatalog_GetCollectionByName_Call) Run(run func(ctx context.Context, dbID int64, dbName string, 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].(string), args[4].(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, 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)

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

	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
}

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

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

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

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

	return r0, r1
}

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

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

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

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

func (_c *RootCoordCatalog_GetPrivilegeGroup_Call) RunAndReturn(run func(context.Context, string) (*milvuspb.PrivilegeGroupInfo, error)) *RootCoordCatalog_GetPrivilegeGroup_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)

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

	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)

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

	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)

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

	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)

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

	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
}

// ListFileResource provides a mock function with given fields: ctx
func (_m *RootCoordCatalog) 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
}

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

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

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

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

func (_c *RootCoordCatalog_ListFileResource_Call) RunAndReturn(run func(context.Context) ([]*internalpb.FileResourceInfo, uint64, error)) *RootCoordCatalog_ListFileResource_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)

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

	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) ([]*milvuspb.GrantEntity, error) {
	ret := _m.Called(ctx, tenant)

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

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

	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 []*milvuspb.GrantEntity, _a1 error) *RootCoordCatalog_ListPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

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

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

	return r0, r1
}

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

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

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

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

func (_c *RootCoordCatalog_ListPrivilegeGroups_Call) RunAndReturn(run func(context.Context) ([]*milvuspb.PrivilegeGroupInfo, error)) *RootCoordCatalog_ListPrivilegeGroups_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)

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

	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)

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

	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)

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

	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
}

// MigrateGrantCollectionName provides a mock function with given fields: ctx, tenant, oldDBName, oldName, newDBName, newName
func (_m *RootCoordCatalog) MigrateGrantCollectionName(ctx context.Context, tenant string, oldDBName string, oldName string, newDBName string, newName string) error {
	ret := _m.Called(ctx, tenant, oldDBName, oldName, newDBName, newName)

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

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

	return r0
}

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

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

func (_c *RootCoordCatalog_MigrateGrantCollectionName_Call) Run(run func(ctx context.Context, tenant string, oldDBName string, oldName string, newDBName string, newName string)) *RootCoordCatalog_MigrateGrantCollectionName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string))
	})
	return _c
}

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

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

// RemoveFileResource provides a mock function with given fields: ctx, resourceID, version
func (_m *RootCoordCatalog) 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
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

// SaveFileResource provides a mock function with given fields: ctx, resource, version
func (_m *RootCoordCatalog) 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
}

// RootCoordCatalog_SaveFileResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveFileResource'
type RootCoordCatalog_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 *RootCoordCatalog_Expecter) SaveFileResource(ctx interface{}, resource interface{}, version interface{}) *RootCoordCatalog_SaveFileResource_Call {
	return &RootCoordCatalog_SaveFileResource_Call{Call: _e.mock.On("SaveFileResource", ctx, resource, version)}
}

func (_c *RootCoordCatalog_SaveFileResource_Call) Run(run func(ctx context.Context, resource *internalpb.FileResourceInfo, version uint64)) *RootCoordCatalog_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 *RootCoordCatalog_SaveFileResource_Call) Return(_a0 error) *RootCoordCatalog_SaveFileResource_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// SavePrivilegeGroup provides a mock function with given fields: ctx, data
func (_m *RootCoordCatalog) SavePrivilegeGroup(ctx context.Context, data *milvuspb.PrivilegeGroupInfo) error {
	ret := _m.Called(ctx, data)

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

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

	return r0
}

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

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

func (_c *RootCoordCatalog_SavePrivilegeGroup_Call) Run(run func(ctx context.Context, data *milvuspb.PrivilegeGroupInfo)) *RootCoordCatalog_SavePrivilegeGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*milvuspb.PrivilegeGroupInfo))
	})
	return _c
}

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

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

// Update provides a mock function with given fields: ctx, ts, actions
func (_m *RootCoordCatalog) Update(ctx context.Context, ts uint64, actions ...metastore.UpdateAction) error {
	_va := make([]interface{}, len(actions))
	for _i := range actions {
		_va[_i] = actions[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, ts)
	_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, uint64, ...metastore.UpdateAction) error); ok {
		r0 = rf(ctx, ts, actions...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

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

func (_c *RootCoordCatalog_Update_Call) RunAndReturn(run func(context.Context, uint64, ...metastore.UpdateAction) error) *RootCoordCatalog_Update_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
}
