// Code generated by MockGen. DO NOT EDIT.
// Source: ./internel/dao/rbac/rbac.go

// Package rbac is a generated GoMock package.
package rbac

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	ddb "github.com/tidbcloud/account/internel/dao/ddb"
	entity "github.com/tidbcloud/account/internel/dao/entity"
	gorm "gorm.io/gorm"
)

// MockRbacDaoIface is a mock of RbacDaoIface interface.
type MockRbacDaoIface struct {
	ctrl     *gomock.Controller
	recorder *MockRbacDaoIfaceMockRecorder
}

// MockRbacDaoIfaceMockRecorder is the mock recorder for MockRbacDaoIface.
type MockRbacDaoIfaceMockRecorder struct {
	mock *MockRbacDaoIface
}

// NewMockRbacDaoIface creates a new mock instance.
func NewMockRbacDaoIface(ctrl *gomock.Controller) *MockRbacDaoIface {
	mock := &MockRbacDaoIface{ctrl: ctrl}
	mock.recorder = &MockRbacDaoIfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRbacDaoIface) EXPECT() *MockRbacDaoIfaceMockRecorder {
	return m.recorder
}

// CreateRbacPrivilege mocks base method.
func (m *MockRbacDaoIface) CreateRbacPrivilege(ctx context.Context, tx *gorm.DB, resourceUri, url, system, description string) (*entity.RbacPrivilege, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRbacPrivilege", ctx, tx, resourceUri, url, system, description)
	ret0, _ := ret[0].(*entity.RbacPrivilege)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRbacPrivilege indicates an expected call of CreateRbacPrivilege.
func (mr *MockRbacDaoIfaceMockRecorder) CreateRbacPrivilege(ctx, tx, resourceUri, url, system, description interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRbacPrivilege", reflect.TypeOf((*MockRbacDaoIface)(nil).CreateRbacPrivilege), ctx, tx, resourceUri, url, system, description)
}

// CreateRbacRole mocks base method.
func (m *MockRbacDaoIface) CreateRbacRole(ctx context.Context, tx *gorm.DB, name, description string, scopeType entity.ScopeType, displayName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRbacRole", ctx, tx, name, description, scopeType, displayName)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateRbacRole indicates an expected call of CreateRbacRole.
func (mr *MockRbacDaoIfaceMockRecorder) CreateRbacRole(ctx, tx, name, description, scopeType, displayName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRbacRole", reflect.TypeOf((*MockRbacDaoIface)(nil).CreateRbacRole), ctx, tx, name, description, scopeType, displayName)
}

// CreateRbacRolePrivilege mocks base method.
func (m *MockRbacDaoIface) CreateRbacRolePrivilege(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, roleID uint64, privilegeIDs []uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRbacRolePrivilege", ctx, tx, ddb, roleID, privilegeIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateRbacRolePrivilege indicates an expected call of CreateRbacRolePrivilege.
func (mr *MockRbacDaoIfaceMockRecorder) CreateRbacRolePrivilege(ctx, tx, ddb, roleID, privilegeIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRbacRolePrivilege", reflect.TypeOf((*MockRbacDaoIface)(nil).CreateRbacRolePrivilege), ctx, tx, ddb, roleID, privilegeIDs)
}

// DeleteRbacPrivilege mocks base method.
func (m *MockRbacDaoIface) DeleteRbacPrivilege(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRbacPrivilege", ctx, tx, ddb, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRbacPrivilege indicates an expected call of DeleteRbacPrivilege.
func (mr *MockRbacDaoIfaceMockRecorder) DeleteRbacPrivilege(ctx, tx, ddb, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRbacPrivilege", reflect.TypeOf((*MockRbacDaoIface)(nil).DeleteRbacPrivilege), ctx, tx, ddb, id)
}

// DeleteRbacRole mocks base method.
func (m *MockRbacDaoIface) DeleteRbacRole(ctx context.Context, tx *gorm.DB, rbacRoleID uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRbacRole", ctx, tx, rbacRoleID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRbacRole indicates an expected call of DeleteRbacRole.
func (mr *MockRbacDaoIfaceMockRecorder) DeleteRbacRole(ctx, tx, rbacRoleID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRbacRole", reflect.TypeOf((*MockRbacDaoIface)(nil).DeleteRbacRole), ctx, tx, rbacRoleID)
}

// DeleteRbacRolePrivilege mocks base method.
func (m *MockRbacDaoIface) DeleteRbacRolePrivilege(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, roleID, privilegeID uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRbacRolePrivilege", ctx, tx, ddb, roleID, privilegeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRbacRolePrivilege indicates an expected call of DeleteRbacRolePrivilege.
func (mr *MockRbacDaoIfaceMockRecorder) DeleteRbacRolePrivilege(ctx, tx, ddb, roleID, privilegeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRbacRolePrivilege", reflect.TypeOf((*MockRbacDaoIface)(nil).DeleteRbacRolePrivilege), ctx, tx, ddb, roleID, privilegeID)
}

// DeleteRbacRolePrivilegeByPrivilegeID mocks base method.
func (m *MockRbacDaoIface) DeleteRbacRolePrivilegeByPrivilegeID(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, privilegeID uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRbacRolePrivilegeByPrivilegeID", ctx, tx, ddb, privilegeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRbacRolePrivilegeByPrivilegeID indicates an expected call of DeleteRbacRolePrivilegeByPrivilegeID.
func (mr *MockRbacDaoIfaceMockRecorder) DeleteRbacRolePrivilegeByPrivilegeID(ctx, tx, ddb, privilegeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRbacRolePrivilegeByPrivilegeID", reflect.TypeOf((*MockRbacDaoIface)(nil).DeleteRbacRolePrivilegeByPrivilegeID), ctx, tx, ddb, privilegeID)
}

// DeleteRbacRolePrivilegeByRoleID mocks base method.
func (m *MockRbacDaoIface) DeleteRbacRolePrivilegeByRoleID(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, roleID uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRbacRolePrivilegeByRoleID", ctx, tx, ddb, roleID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRbacRolePrivilegeByRoleID indicates an expected call of DeleteRbacRolePrivilegeByRoleID.
func (mr *MockRbacDaoIfaceMockRecorder) DeleteRbacRolePrivilegeByRoleID(ctx, tx, ddb, roleID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRbacRolePrivilegeByRoleID", reflect.TypeOf((*MockRbacDaoIface)(nil).DeleteRbacRolePrivilegeByRoleID), ctx, tx, ddb, roleID)
}

// GetRbacPrivilegeByID mocks base method.
func (m *MockRbacDaoIface) GetRbacPrivilegeByID(ctx context.Context, tx *gorm.DB, id uint64) (*entity.RbacPrivilege, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRbacPrivilegeByID", ctx, tx, id)
	ret0, _ := ret[0].(*entity.RbacPrivilege)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRbacPrivilegeByID indicates an expected call of GetRbacPrivilegeByID.
func (mr *MockRbacDaoIfaceMockRecorder) GetRbacPrivilegeByID(ctx, tx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRbacPrivilegeByID", reflect.TypeOf((*MockRbacDaoIface)(nil).GetRbacPrivilegeByID), ctx, tx, id)
}

// GetRbacPrivilegeByResourceUri mocks base method.
func (m *MockRbacDaoIface) GetRbacPrivilegeByResourceUri(ctx context.Context, tx *gorm.DB, resourceUri string) (*entity.RbacPrivilege, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRbacPrivilegeByResourceUri", ctx, tx, resourceUri)
	ret0, _ := ret[0].(*entity.RbacPrivilege)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRbacPrivilegeByResourceUri indicates an expected call of GetRbacPrivilegeByResourceUri.
func (mr *MockRbacDaoIfaceMockRecorder) GetRbacPrivilegeByResourceUri(ctx, tx, resourceUri interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRbacPrivilegeByResourceUri", reflect.TypeOf((*MockRbacDaoIface)(nil).GetRbacPrivilegeByResourceUri), ctx, tx, resourceUri)
}

// GetRbacRoleByID mocks base method.
func (m *MockRbacDaoIface) GetRbacRoleByID(ctx context.Context, tx *gorm.DB, rbacRoleID uint64) (*entity.RbacRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRbacRoleByID", ctx, tx, rbacRoleID)
	ret0, _ := ret[0].(*entity.RbacRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRbacRoleByID indicates an expected call of GetRbacRoleByID.
func (mr *MockRbacDaoIfaceMockRecorder) GetRbacRoleByID(ctx, tx, rbacRoleID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRbacRoleByID", reflect.TypeOf((*MockRbacDaoIface)(nil).GetRbacRoleByID), ctx, tx, rbacRoleID)
}

// GetRbacRoleByName mocks base method.
func (m *MockRbacDaoIface) GetRbacRoleByName(ctx context.Context, tx *gorm.DB, name string) (*entity.RbacRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRbacRoleByName", ctx, tx, name)
	ret0, _ := ret[0].(*entity.RbacRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRbacRoleByName indicates an expected call of GetRbacRoleByName.
func (mr *MockRbacDaoIfaceMockRecorder) GetRbacRoleByName(ctx, tx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRbacRoleByName", reflect.TypeOf((*MockRbacDaoIface)(nil).GetRbacRoleByName), ctx, tx, name)
}

// GetRbacRoleByNameIn mocks base method.
func (m *MockRbacDaoIface) GetRbacRoleByNameIn(ctx context.Context, tx *gorm.DB, names []string) ([]entity.RbacRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRbacRoleByNameIn", ctx, tx, names)
	ret0, _ := ret[0].([]entity.RbacRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRbacRoleByNameIn indicates an expected call of GetRbacRoleByNameIn.
func (mr *MockRbacDaoIfaceMockRecorder) GetRbacRoleByNameIn(ctx, tx, names interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRbacRoleByNameIn", reflect.TypeOf((*MockRbacDaoIface)(nil).GetRbacRoleByNameIn), ctx, tx, names)
}

// ListRbacPrivileges mocks base method.
func (m *MockRbacDaoIface) ListRbacPrivileges(ctx context.Context, tx *gorm.DB, param ListPrivilegeParam) (*ListPrivilegeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRbacPrivileges", ctx, tx, param)
	ret0, _ := ret[0].(*ListPrivilegeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRbacPrivileges indicates an expected call of ListRbacPrivileges.
func (mr *MockRbacDaoIfaceMockRecorder) ListRbacPrivileges(ctx, tx, param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRbacPrivileges", reflect.TypeOf((*MockRbacDaoIface)(nil).ListRbacPrivileges), ctx, tx, param)
}

// ListRbacPrivilegesByIDs mocks base method.
func (m *MockRbacDaoIface) ListRbacPrivilegesByIDs(ctx context.Context, tx *gorm.DB, id []entity.ID) ([]entity.RbacPrivilege, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRbacPrivilegesByIDs", ctx, tx, id)
	ret0, _ := ret[0].([]entity.RbacPrivilege)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRbacPrivilegesByIDs indicates an expected call of ListRbacPrivilegesByIDs.
func (mr *MockRbacDaoIfaceMockRecorder) ListRbacPrivilegesByIDs(ctx, tx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRbacPrivilegesByIDs", reflect.TypeOf((*MockRbacDaoIface)(nil).ListRbacPrivilegesByIDs), ctx, tx, id)
}

// ListRbacPrivilegesIDsByRoleID mocks base method.
func (m *MockRbacDaoIface) ListRbacPrivilegesIDsByRoleID(ctx context.Context, tx *gorm.DB, roleIDs []uint64) ([]entity.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRbacPrivilegesIDsByRoleID", ctx, tx, roleIDs)
	ret0, _ := ret[0].([]entity.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRbacPrivilegesIDsByRoleID indicates an expected call of ListRbacPrivilegesIDsByRoleID.
func (mr *MockRbacDaoIfaceMockRecorder) ListRbacPrivilegesIDsByRoleID(ctx, tx, roleIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRbacPrivilegesIDsByRoleID", reflect.TypeOf((*MockRbacDaoIface)(nil).ListRbacPrivilegesIDsByRoleID), ctx, tx, roleIDs)
}

// ListRbacRolePrivileges mocks base method.
func (m *MockRbacDaoIface) ListRbacRolePrivileges(ctx context.Context, tx *gorm.DB, filter RolePrivilegeFilter) ([]entity.RbacRolePrivilege, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRbacRolePrivileges", ctx, tx, filter)
	ret0, _ := ret[0].([]entity.RbacRolePrivilege)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRbacRolePrivileges indicates an expected call of ListRbacRolePrivileges.
func (mr *MockRbacDaoIfaceMockRecorder) ListRbacRolePrivileges(ctx, tx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRbacRolePrivileges", reflect.TypeOf((*MockRbacDaoIface)(nil).ListRbacRolePrivileges), ctx, tx, filter)
}

// ListRbacRoles mocks base method.
func (m *MockRbacDaoIface) ListRbacRoles(ctx context.Context, tx *gorm.DB) ([]entity.RbacRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRbacRoles", ctx, tx)
	ret0, _ := ret[0].([]entity.RbacRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRbacRoles indicates an expected call of ListRbacRoles.
func (mr *MockRbacDaoIfaceMockRecorder) ListRbacRoles(ctx, tx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRbacRoles", reflect.TypeOf((*MockRbacDaoIface)(nil).ListRbacRoles), ctx, tx)
}

// ListRbacRolesByIDs mocks base method.
func (m *MockRbacDaoIface) ListRbacRolesByIDs(ctx context.Context, tx *gorm.DB, rbacRoleIDs []uint64) ([]entity.RbacRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRbacRolesByIDs", ctx, tx, rbacRoleIDs)
	ret0, _ := ret[0].([]entity.RbacRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRbacRolesByIDs indicates an expected call of ListRbacRolesByIDs.
func (mr *MockRbacDaoIfaceMockRecorder) ListRbacRolesByIDs(ctx, tx, rbacRoleIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRbacRolesByIDs", reflect.TypeOf((*MockRbacDaoIface)(nil).ListRbacRolesByIDs), ctx, tx, rbacRoleIDs)
}

// TraverseRbacRoles mocks base method.
func (m *MockRbacDaoIface) TraverseRbacRoles(ctx context.Context, tx *gorm.DB, param *ListRoleParam) (*ListRoleResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TraverseRbacRoles", ctx, tx, param)
	ret0, _ := ret[0].(*ListRoleResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TraverseRbacRoles indicates an expected call of TraverseRbacRoles.
func (mr *MockRbacDaoIfaceMockRecorder) TraverseRbacRoles(ctx, tx, param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TraverseRbacRoles", reflect.TypeOf((*MockRbacDaoIface)(nil).TraverseRbacRoles), ctx, tx, param)
}

// UpdateRbacPrivilege mocks base method.
func (m *MockRbacDaoIface) UpdateRbacPrivilege(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, id uint64, resourceUri, url, system, description string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRbacPrivilege", ctx, tx, ddb, id, resourceUri, url, system, description)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRbacPrivilege indicates an expected call of UpdateRbacPrivilege.
func (mr *MockRbacDaoIfaceMockRecorder) UpdateRbacPrivilege(ctx, tx, ddb, id, resourceUri, url, system, description interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRbacPrivilege", reflect.TypeOf((*MockRbacDaoIface)(nil).UpdateRbacPrivilege), ctx, tx, ddb, id, resourceUri, url, system, description)
}

// UpdateRbacRole mocks base method.
func (m *MockRbacDaoIface) UpdateRbacRole(ctx context.Context, tx *gorm.DB, rbacRoleID uint64, name, description string, scopeType entity.ScopeType, displayName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRbacRole", ctx, tx, rbacRoleID, name, description, scopeType, displayName)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRbacRole indicates an expected call of UpdateRbacRole.
func (mr *MockRbacDaoIfaceMockRecorder) UpdateRbacRole(ctx, tx, rbacRoleID, name, description, scopeType, displayName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRbacRole", reflect.TypeOf((*MockRbacDaoIface)(nil).UpdateRbacRole), ctx, tx, rbacRoleID, name, description, scopeType, displayName)
}