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

package mockrootcoord

import (
	context "context"

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

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

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

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

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

type IMetaTable_Expecter struct {
	mock *mock.Mock
}

func (_m *IMetaTable) EXPECT() *IMetaTable_Expecter {
	return &IMetaTable_Expecter{mock: &_m.Mock}
}

// AddCollection provides a mock function with given fields: ctx, coll
func (_m *IMetaTable) AddCollection(ctx context.Context, coll *model.Collection) error {
	ret := _m.Called(ctx, coll)

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

	return r0
}

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

// AddCollection is a helper method to define mock.On call
//  - ctx context.Context
//  - coll *model.Collection
func (_e *IMetaTable_Expecter) AddCollection(ctx interface{}, coll interface{}) *IMetaTable_AddCollection_Call {
	return &IMetaTable_AddCollection_Call{Call: _e.mock.On("AddCollection", ctx, coll)}
}

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

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

// AddCredential provides a mock function with given fields: credInfo
func (_m *IMetaTable) AddCredential(credInfo *internalpb.CredentialInfo) error {
	ret := _m.Called(credInfo)

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

	return r0
}

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

// AddCredential is a helper method to define mock.On call
//  - credInfo *internalpb.CredentialInfo
func (_e *IMetaTable_Expecter) AddCredential(credInfo interface{}) *IMetaTable_AddCredential_Call {
	return &IMetaTable_AddCredential_Call{Call: _e.mock.On("AddCredential", credInfo)}
}

func (_c *IMetaTable_AddCredential_Call) Run(run func(credInfo *internalpb.CredentialInfo)) *IMetaTable_AddCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*internalpb.CredentialInfo))
	})
	return _c
}

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

// AddPartition provides a mock function with given fields: ctx, partition
func (_m *IMetaTable) AddPartition(ctx context.Context, partition *model.Partition) error {
	ret := _m.Called(ctx, partition)

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

	return r0
}

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

// AddPartition is a helper method to define mock.On call
//  - ctx context.Context
//  - partition *model.Partition
func (_e *IMetaTable_Expecter) AddPartition(ctx interface{}, partition interface{}) *IMetaTable_AddPartition_Call {
	return &IMetaTable_AddPartition_Call{Call: _e.mock.On("AddPartition", ctx, partition)}
}

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

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

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

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

	return r0
}

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

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

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

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

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

	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
}

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

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

func (_c *IMetaTable_AlterCollection_Call) Run(run func(ctx context.Context, oldColl *model.Collection, newColl *model.Collection, ts uint64)) *IMetaTable_AlterCollection_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 *IMetaTable_AlterCollection_Call) Return(_a0 error) *IMetaTable_AlterCollection_Call {
	_c.Call.Return(_a0)
	return _c
}

// AlterCredential provides a mock function with given fields: credInfo
func (_m *IMetaTable) AlterCredential(credInfo *internalpb.CredentialInfo) error {
	ret := _m.Called(credInfo)

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

	return r0
}

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

// AlterCredential is a helper method to define mock.On call
//  - credInfo *internalpb.CredentialInfo
func (_e *IMetaTable_Expecter) AlterCredential(credInfo interface{}) *IMetaTable_AlterCredential_Call {
	return &IMetaTable_AlterCredential_Call{Call: _e.mock.On("AlterCredential", credInfo)}
}

func (_c *IMetaTable_AlterCredential_Call) Run(run func(credInfo *internalpb.CredentialInfo)) *IMetaTable_AlterCredential_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*internalpb.CredentialInfo))
	})
	return _c
}

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

// ChangeCollectionState provides a mock function with given fields: ctx, collectionID, state, ts
func (_m *IMetaTable) ChangeCollectionState(ctx context.Context, collectionID int64, state etcdpb.CollectionState, ts uint64) error {
	ret := _m.Called(ctx, collectionID, state, ts)

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

	return r0
}

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

// ChangeCollectionState is a helper method to define mock.On call
//  - ctx context.Context
//  - collectionID int64
//  - state etcdpb.CollectionState
//  - ts uint64
func (_e *IMetaTable_Expecter) ChangeCollectionState(ctx interface{}, collectionID interface{}, state interface{}, ts interface{}) *IMetaTable_ChangeCollectionState_Call {
	return &IMetaTable_ChangeCollectionState_Call{Call: _e.mock.On("ChangeCollectionState", ctx, collectionID, state, ts)}
}

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

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

// ChangePartitionState provides a mock function with given fields: ctx, collectionID, partitionID, state, ts
func (_m *IMetaTable) ChangePartitionState(ctx context.Context, collectionID int64, partitionID int64, state etcdpb.PartitionState, ts uint64) error {
	ret := _m.Called(ctx, collectionID, partitionID, state, ts)

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

	return r0
}

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

// ChangePartitionState is a helper method to define mock.On call
//  - ctx context.Context
//  - collectionID int64
//  - partitionID int64
//  - state etcdpb.PartitionState
//  - ts uint64
func (_e *IMetaTable_Expecter) ChangePartitionState(ctx interface{}, collectionID interface{}, partitionID interface{}, state interface{}, ts interface{}) *IMetaTable_ChangePartitionState_Call {
	return &IMetaTable_ChangePartitionState_Call{Call: _e.mock.On("ChangePartitionState", ctx, collectionID, partitionID, state, ts)}
}

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

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

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

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

	return r0
}

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

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

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

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

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

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

	return r0
}

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

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

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

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

// DeleteCredential provides a mock function with given fields: username
func (_m *IMetaTable) DeleteCredential(username string) error {
	ret := _m.Called(username)

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

	return r0
}

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

// DeleteCredential is a helper method to define mock.On call
//  - username string
func (_e *IMetaTable_Expecter) DeleteCredential(username interface{}) *IMetaTable_DeleteCredential_Call {
	return &IMetaTable_DeleteCredential_Call{Call: _e.mock.On("DeleteCredential", username)}
}

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

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

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

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

	return r0
}

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

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

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

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

// DropGrant provides a mock function with given fields: tenant, role
func (_m *IMetaTable) DropGrant(tenant string, role *milvuspb.RoleEntity) error {
	ret := _m.Called(tenant, role)

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

	return r0
}

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

// DropGrant is a helper method to define mock.On call
//  - tenant string
//  - role *milvuspb.RoleEntity
func (_e *IMetaTable_Expecter) DropGrant(tenant interface{}, role interface{}) *IMetaTable_DropGrant_Call {
	return &IMetaTable_DropGrant_Call{Call: _e.mock.On("DropGrant", tenant, role)}
}

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

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

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

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

	return r0
}

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

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

func (_c *IMetaTable_DropRole_Call) Run(run func(tenant string, roleName string)) *IMetaTable_DropRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

// GetCollectionVirtualChannels provides a mock function with given fields: colID
func (_m *IMetaTable) GetCollectionVirtualChannels(colID int64) []string {
	ret := _m.Called(colID)

	var r0 []string
	if rf, ok := ret.Get(0).(func(int64) []string); ok {
		r0 = rf(colID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}

	return r0
}

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

// GetCollectionVirtualChannels is a helper method to define mock.On call
//  - colID int64
func (_e *IMetaTable_Expecter) GetCollectionVirtualChannels(colID interface{}) *IMetaTable_GetCollectionVirtualChannels_Call {
	return &IMetaTable_GetCollectionVirtualChannels_Call{Call: _e.mock.On("GetCollectionVirtualChannels", colID)}
}

func (_c *IMetaTable_GetCollectionVirtualChannels_Call) Run(run func(colID int64)) *IMetaTable_GetCollectionVirtualChannels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *IMetaTable_GetCollectionVirtualChannels_Call) Return(_a0 []string) *IMetaTable_GetCollectionVirtualChannels_Call {
	_c.Call.Return(_a0)
	return _c
}

// GetCredential provides a mock function with given fields: username
func (_m *IMetaTable) GetCredential(username string) (*internalpb.CredentialInfo, error) {
	ret := _m.Called(username)

	var r0 *internalpb.CredentialInfo
	if rf, ok := ret.Get(0).(func(string) *internalpb.CredentialInfo); ok {
		r0 = rf(username)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*internalpb.CredentialInfo)
		}
	}

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

	return r0, r1
}

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

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

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

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

// GetPartitionByName provides a mock function with given fields: collID, partitionName, ts
func (_m *IMetaTable) GetPartitionByName(collID int64, partitionName string, ts uint64) (int64, error) {
	ret := _m.Called(collID, partitionName, ts)

	var r0 int64
	if rf, ok := ret.Get(0).(func(int64, string, uint64) int64); ok {
		r0 = rf(collID, partitionName, ts)
	} else {
		r0 = ret.Get(0).(int64)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, string, uint64) error); ok {
		r1 = rf(collID, partitionName, ts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPartitionByName is a helper method to define mock.On call
//  - collID int64
//  - partitionName string
//  - ts uint64
func (_e *IMetaTable_Expecter) GetPartitionByName(collID interface{}, partitionName interface{}, ts interface{}) *IMetaTable_GetPartitionByName_Call {
	return &IMetaTable_GetPartitionByName_Call{Call: _e.mock.On("GetPartitionByName", collID, partitionName, ts)}
}

func (_c *IMetaTable_GetPartitionByName_Call) Run(run func(collID int64, partitionName string, ts uint64)) *IMetaTable_GetPartitionByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(string), args[2].(uint64))
	})
	return _c
}

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

// GetPartitionNameByID provides a mock function with given fields: collID, partitionID, ts
func (_m *IMetaTable) GetPartitionNameByID(collID int64, partitionID int64, ts uint64) (string, error) {
	ret := _m.Called(collID, partitionID, ts)

	var r0 string
	if rf, ok := ret.Get(0).(func(int64, int64, uint64) string); ok {
		r0 = rf(collID, partitionID, ts)
	} else {
		r0 = ret.Get(0).(string)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, uint64) error); ok {
		r1 = rf(collID, partitionID, ts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPartitionNameByID is a helper method to define mock.On call
//  - collID int64
//  - partitionID int64
//  - ts uint64
func (_e *IMetaTable_Expecter) GetPartitionNameByID(collID interface{}, partitionID interface{}, ts interface{}) *IMetaTable_GetPartitionNameByID_Call {
	return &IMetaTable_GetPartitionNameByID_Call{Call: _e.mock.On("GetPartitionNameByID", collID, partitionID, ts)}
}

func (_c *IMetaTable_GetPartitionNameByID_Call) Run(run func(collID int64, partitionID int64, ts uint64)) *IMetaTable_GetPartitionNameByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(int64), args[2].(uint64))
	})
	return _c
}

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

// IsAlias provides a mock function with given fields: name
func (_m *IMetaTable) IsAlias(name string) bool {
	ret := _m.Called(name)

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

	return r0
}

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

// IsAlias is a helper method to define mock.On call
//  - name string
func (_e *IMetaTable_Expecter) IsAlias(name interface{}) *IMetaTable_IsAlias_Call {
	return &IMetaTable_IsAlias_Call{Call: _e.mock.On("IsAlias", name)}
}

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

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

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

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

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

	return r0, r1
}

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

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

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

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

// ListAliasesByID provides a mock function with given fields: collID
func (_m *IMetaTable) ListAliasesByID(collID int64) []string {
	ret := _m.Called(collID)

	var r0 []string
	if rf, ok := ret.Get(0).(func(int64) []string); ok {
		r0 = rf(collID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}

	return r0
}

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

// ListAliasesByID is a helper method to define mock.On call
//  - collID int64
func (_e *IMetaTable_Expecter) ListAliasesByID(collID interface{}) *IMetaTable_ListAliasesByID_Call {
	return &IMetaTable_ListAliasesByID_Call{Call: _e.mock.On("ListAliasesByID", collID)}
}

func (_c *IMetaTable_ListAliasesByID_Call) Run(run func(collID int64)) *IMetaTable_ListAliasesByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *IMetaTable_ListAliasesByID_Call) Return(_a0 []string) *IMetaTable_ListAliasesByID_Call {
	_c.Call.Return(_a0)
	return _c
}

// ListCollectionPhysicalChannels provides a mock function with given fields:
func (_m *IMetaTable) ListCollectionPhysicalChannels() map[int64][]string {
	ret := _m.Called()

	var r0 map[int64][]string
	if rf, ok := ret.Get(0).(func() map[int64][]string); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[int64][]string)
		}
	}

	return r0
}

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

// ListCollectionPhysicalChannels is a helper method to define mock.On call
func (_e *IMetaTable_Expecter) ListCollectionPhysicalChannels() *IMetaTable_ListCollectionPhysicalChannels_Call {
	return &IMetaTable_ListCollectionPhysicalChannels_Call{Call: _e.mock.On("ListCollectionPhysicalChannels")}
}

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

func (_c *IMetaTable_ListCollectionPhysicalChannels_Call) Return(_a0 map[int64][]string) *IMetaTable_ListCollectionPhysicalChannels_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	return r0, r1
}

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

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

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

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

// ListCredentialUsernames provides a mock function with given fields:
func (_m *IMetaTable) ListCredentialUsernames() (*milvuspb.ListCredUsersResponse, error) {
	ret := _m.Called()

	var r0 *milvuspb.ListCredUsersResponse
	if rf, ok := ret.Get(0).(func() *milvuspb.ListCredUsersResponse); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*milvuspb.ListCredUsersResponse)
		}
	}

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

	return r0, r1
}

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

// ListCredentialUsernames is a helper method to define mock.On call
func (_e *IMetaTable_Expecter) ListCredentialUsernames() *IMetaTable_ListCredentialUsernames_Call {
	return &IMetaTable_ListCredentialUsernames_Call{Call: _e.mock.On("ListCredentialUsernames")}
}

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

	return r0
}

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

// OperatePrivilege is a helper method to define mock.On call
//  - tenant string
//  - entity *milvuspb.GrantEntity
//  - operateType milvuspb.OperatePrivilegeType
func (_e *IMetaTable_Expecter) OperatePrivilege(tenant interface{}, entity interface{}, operateType interface{}) *IMetaTable_OperatePrivilege_Call {
	return &IMetaTable_OperatePrivilege_Call{Call: _e.mock.On("OperatePrivilege", tenant, entity, operateType)}
}

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

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

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

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

	return r0
}

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

// OperateUserRole is a helper method to define mock.On call
//  - tenant string
//  - userEntity *milvuspb.UserEntity
//  - roleEntity *milvuspb.RoleEntity
//  - operateType milvuspb.OperateUserRoleType
func (_e *IMetaTable_Expecter) OperateUserRole(tenant interface{}, userEntity interface{}, roleEntity interface{}, operateType interface{}) *IMetaTable_OperateUserRole_Call {
	return &IMetaTable_OperateUserRole_Call{Call: _e.mock.On("OperateUserRole", tenant, userEntity, roleEntity, operateType)}
}

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

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

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

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

	return r0
}

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

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

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

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

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

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

	return r0
}

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

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

func (_c *IMetaTable_RemovePartition_Call) Run(run func(ctx context.Context, collectionID int64, partitionID int64, ts uint64)) *IMetaTable_RemovePartition_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 *IMetaTable_RemovePartition_Call) Return(_a0 error) *IMetaTable_RemovePartition_Call {
	_c.Call.Return(_a0)
	return _c
}

// RenameCollection provides a mock function with given fields: ctx, oldName, newName, ts
func (_m *IMetaTable) RenameCollection(ctx context.Context, oldName string, newName string, ts uint64) error {
	ret := _m.Called(ctx, oldName, newName, ts)

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

	return r0
}

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

// RenameCollection is a helper method to define mock.On call
//  - ctx context.Context
//  - oldName string
//  - newName string
//  - ts uint64
func (_e *IMetaTable_Expecter) RenameCollection(ctx interface{}, oldName interface{}, newName interface{}, ts interface{}) *IMetaTable_RenameCollection_Call {
	return &IMetaTable_RenameCollection_Call{Call: _e.mock.On("RenameCollection", ctx, oldName, newName, ts)}
}

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

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

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

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

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

	return r0, r1
}

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

// SelectGrant is a helper method to define mock.On call
//  - tenant string
//  - entity *milvuspb.GrantEntity
func (_e *IMetaTable_Expecter) SelectGrant(tenant interface{}, entity interface{}) *IMetaTable_SelectGrant_Call {
	return &IMetaTable_SelectGrant_Call{Call: _e.mock.On("SelectGrant", tenant, entity)}
}

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

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

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

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

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

	return r0, r1
}

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

// SelectRole is a helper method to define mock.On call
//  - tenant string
//  - entity *milvuspb.RoleEntity
//  - includeUserInfo bool
func (_e *IMetaTable_Expecter) SelectRole(tenant interface{}, entity interface{}, includeUserInfo interface{}) *IMetaTable_SelectRole_Call {
	return &IMetaTable_SelectRole_Call{Call: _e.mock.On("SelectRole", tenant, entity, includeUserInfo)}
}

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

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

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

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

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

	return r0, r1
}

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

// SelectUser is a helper method to define mock.On call
//  - tenant string
//  - entity *milvuspb.UserEntity
//  - includeRoleInfo bool
func (_e *IMetaTable_Expecter) SelectUser(tenant interface{}, entity interface{}, includeRoleInfo interface{}) *IMetaTable_SelectUser_Call {
	return &IMetaTable_SelectUser_Call{Call: _e.mock.On("SelectUser", tenant, entity, includeRoleInfo)}
}

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

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

type mockConstructorTestingTNewIMetaTable interface {
	mock.TestingT
	Cleanup(func())
}

// NewIMetaTable creates a new instance of IMetaTable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewIMetaTable(t mockConstructorTestingTNewIMetaTable) *IMetaTable {
	mock := &IMetaTable{}
	mock.Mock.Test(t)

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

	return mock
}