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

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

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

// MockRoleDaoIface is a mock of RoleDaoIface interface.
type MockRoleDaoIface struct {
	ctrl     *gomock.Controller
	recorder *MockRoleDaoIfaceMockRecorder
}

// MockRoleDaoIfaceMockRecorder is the mock recorder for MockRoleDaoIface.
type MockRoleDaoIfaceMockRecorder struct {
	mock *MockRoleDaoIface
}

// NewMockRoleDaoIface creates a new mock instance.
func NewMockRoleDaoIface(ctrl *gomock.Controller) *MockRoleDaoIface {
	mock := &MockRoleDaoIface{ctrl: ctrl}
	mock.recorder = &MockRoleDaoIfaceMockRecorder{mock}
	return mock
}

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

// AddOrgRoleForUser mocks base method.
func (m *MockRoleDaoIface) AddOrgRoleForUser(ctx context.Context, tx *gorm.DB, userID, orgID uint64, role string) (*entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrgRoleForUser", ctx, tx, userID, orgID, role)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddOrgRoleForUser indicates an expected call of AddOrgRoleForUser.
func (mr *MockRoleDaoIfaceMockRecorder) AddOrgRoleForUser(ctx, tx, userID, orgID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrgRoleForUser", reflect.TypeOf((*MockRoleDaoIface)(nil).AddOrgRoleForUser), ctx, tx, userID, orgID, role)
}

// AddProjectRoleForUser mocks base method.
func (m *MockRoleDaoIface) AddProjectRoleForUser(ctx context.Context, tx *gorm.DB, userID, projectID uint64, role string) (*entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddProjectRoleForUser", ctx, tx, userID, projectID, role)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddProjectRoleForUser indicates an expected call of AddProjectRoleForUser.
func (mr *MockRoleDaoIfaceMockRecorder) AddProjectRoleForUser(ctx, tx, userID, projectID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProjectRoleForUser", reflect.TypeOf((*MockRoleDaoIface)(nil).AddProjectRoleForUser), ctx, tx, userID, projectID, role)
}

// BatchCreateRoleBindings mocks base method.
func (m *MockRoleDaoIface) BatchCreateRoleBindings(ctx context.Context, tx *gorm.DB, bindings []*entity.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateRoleBindings", ctx, tx, bindings)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// BatchSelectRoleBindings mocks base method.
func (m *MockRoleDaoIface) BatchSelectRoleBindings(ctx context.Context, tx *gorm.DB, idStart uint64, limit int) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchSelectRoleBindings", ctx, tx, idStart, limit)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchSelectRoleBindings indicates an expected call of BatchSelectRoleBindings.
func (mr *MockRoleDaoIfaceMockRecorder) BatchSelectRoleBindings(ctx, tx, idStart, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchSelectRoleBindings", reflect.TypeOf((*MockRoleDaoIface)(nil).BatchSelectRoleBindings), ctx, tx, idStart, limit)
}

// BatchUpdateRoleOrStatus mocks base method.
func (m *MockRoleDaoIface) BatchUpdateRoleOrStatus(ctx context.Context, tx *gorm.DB, filter RoleBindingFilter, paramMap map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpdateRoleOrStatus", ctx, tx, filter, paramMap)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ChangeRoleTo mocks base method.
func (m *MockRoleDaoIface) ChangeRoleTo(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, role, newRole string) (entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeRoleTo", ctx, tx, targetType, targetID, scopeType, scopeID, role, newRole)
	ret0, _ := ret[0].(entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeRoleTo indicates an expected call of ChangeRoleTo.
func (mr *MockRoleDaoIfaceMockRecorder) ChangeRoleTo(ctx, tx, targetType, targetID, scopeType, scopeID, role, newRole interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeRoleTo", reflect.TypeOf((*MockRoleDaoIface)(nil).ChangeRoleTo), ctx, tx, targetType, targetID, scopeType, scopeID, role, newRole)
}

// CreateRole mocks base method.
func (m *MockRoleDaoIface) CreateRole(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, role, status string) (*entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRole", ctx, tx, targetType, targetID, scopeType, scopeID, role, status)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRole indicates an expected call of CreateRole.
func (mr *MockRoleDaoIfaceMockRecorder) CreateRole(ctx, tx, targetType, targetID, scopeType, scopeID, role, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockRoleDaoIface)(nil).CreateRole), ctx, tx, targetType, targetID, scopeType, scopeID, role, status)
}

// CreateRoleBinding mocks base method.
func (m *MockRoleDaoIface) CreateRoleBinding(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID, roleID uint64, status string) (*entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoleBinding", ctx, tx, ddb, targetType, targetID, scopeType, scopeID, roleID, status)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRoleBinding indicates an expected call of CreateRoleBinding.
func (mr *MockRoleDaoIfaceMockRecorder) CreateRoleBinding(ctx, tx, ddb, targetType, targetID, scopeType, scopeID, roleID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoleBinding", reflect.TypeOf((*MockRoleDaoIface)(nil).CreateRoleBinding), ctx, tx, ddb, targetType, targetID, scopeType, scopeID, roleID, status)
}

// DeleteRole mocks base method.
func (m *MockRoleDaoIface) DeleteRole(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, role string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRole", ctx, tx, targetType, targetID, scopeType, scopeID, role)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRole indicates an expected call of DeleteRole.
func (mr *MockRoleDaoIfaceMockRecorder) DeleteRole(ctx, tx, targetType, targetID, scopeType, scopeID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockRoleDaoIface)(nil).DeleteRole), ctx, tx, targetType, targetID, scopeType, scopeID, role)
}

// DeleteRoleBinding mocks base method.
func (m *MockRoleDaoIface) DeleteRoleBinding(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID, roleID uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleBinding", ctx, tx, ddb, targetType, targetID, scopeType, scopeID, roleID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRoleBinding indicates an expected call of DeleteRoleBinding.
func (mr *MockRoleDaoIfaceMockRecorder) DeleteRoleBinding(ctx, tx, ddb, targetType, targetID, scopeType, scopeID, roleID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleBinding", reflect.TypeOf((*MockRoleDaoIface)(nil).DeleteRoleBinding), ctx, tx, ddb, targetType, targetID, scopeType, scopeID, roleID)
}

// DeleteRoleBindingByScopeInfo mocks base method.
func (m *MockRoleDaoIface) DeleteRoleBindingByScopeInfo(ctx context.Context, tx *gorm.DB, scopeType ScopeType, scopeID uint64, targetType TargetType) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleBindingByScopeInfo", ctx, tx, scopeType, scopeID, targetType)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRoleBindingByScopeInfo indicates an expected call of DeleteRoleBindingByScopeInfo.
func (mr *MockRoleDaoIfaceMockRecorder) DeleteRoleBindingByScopeInfo(ctx, tx, scopeType, scopeID, targetType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleBindingByScopeInfo", reflect.TypeOf((*MockRoleDaoIface)(nil).DeleteRoleBindingByScopeInfo), ctx, tx, scopeType, scopeID, targetType)
}

// DeleteRoleBindingByTargetInfo mocks base method.
func (m *MockRoleDaoIface) DeleteRoleBindingByTargetInfo(ctx context.Context, tx *gorm.DB, ddb *ddb.DynamoDBClient, targetType TargetType, targetID uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleBindingByTargetInfo", ctx, tx, ddb, targetType, targetID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRoleBindingByTargetInfo indicates an expected call of DeleteRoleBindingByTargetInfo.
func (mr *MockRoleDaoIfaceMockRecorder) DeleteRoleBindingByTargetInfo(ctx, tx, ddb, targetType, targetID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleBindingByTargetInfo", reflect.TypeOf((*MockRoleDaoIface)(nil).DeleteRoleBindingByTargetInfo), ctx, tx, ddb, targetType, targetID)
}

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

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

// DeleteRoleByTargetAndScope mocks base method.
func (m *MockRoleDaoIface) DeleteRoleByTargetAndScope(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeIDs []uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleByTargetAndScope", ctx, tx, targetType, targetID, scopeType, scopeIDs)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRoleByTargetAndScope indicates an expected call of DeleteRoleByTargetAndScope.
func (mr *MockRoleDaoIfaceMockRecorder) DeleteRoleByTargetAndScope(ctx, tx, targetType, targetID, scopeType, scopeIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleByTargetAndScope", reflect.TypeOf((*MockRoleDaoIface)(nil).DeleteRoleByTargetAndScope), ctx, tx, targetType, targetID, scopeType, scopeIDs)
}

// GetRole mocks base method.
func (m *MockRoleDaoIface) GetRole(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, role string) (*entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRole", ctx, tx, targetType, targetID, scopeType, scopeID, role)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRole indicates an expected call of GetRole.
func (mr *MockRoleDaoIfaceMockRecorder) GetRole(ctx, tx, targetType, targetID, scopeType, scopeID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockRoleDaoIface)(nil).GetRole), ctx, tx, targetType, targetID, scopeType, scopeID, role)
}

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

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

// GetUserOrgIds mocks base method.
func (m *MockRoleDaoIface) GetUserOrgIds(ctx context.Context, tx *gorm.DB, userId uint64, roleBindingStatus []string) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserOrgIds", ctx, tx, userId, roleBindingStatus)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserOrgIds indicates an expected call of GetUserOrgIds.
func (mr *MockRoleDaoIfaceMockRecorder) GetUserOrgIds(ctx, tx, userId, roleBindingStatus interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserOrgIds", reflect.TypeOf((*MockRoleDaoIface)(nil).GetUserOrgIds), ctx, tx, userId, roleBindingStatus)
}

// HasActiveRole mocks base method.
func (m *MockRoleDaoIface) HasActiveRole(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, role string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasActiveRole", ctx, tx, targetType, targetID, scopeType, scopeID, role)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasActiveRole indicates an expected call of HasActiveRole.
func (mr *MockRoleDaoIfaceMockRecorder) HasActiveRole(ctx, tx, targetType, targetID, scopeType, scopeID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasActiveRole", reflect.TypeOf((*MockRoleDaoIface)(nil).HasActiveRole), ctx, tx, targetType, targetID, scopeType, scopeID, role)
}

// LegacyGetUserRoleByOrg mocks base method.
func (m *MockRoleDaoIface) LegacyGetUserRoleByOrg(ctx context.Context, tx *gorm.DB, userID, orgID uint64, status []string) (*entity.RoleBinding, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LegacyGetUserRoleByOrg", ctx, tx, userID, orgID, status)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// LegacyGetUserRoleByOrg indicates an expected call of LegacyGetUserRoleByOrg.
func (mr *MockRoleDaoIfaceMockRecorder) LegacyGetUserRoleByOrg(ctx, tx, userID, orgID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LegacyGetUserRoleByOrg", reflect.TypeOf((*MockRoleDaoIface)(nil).LegacyGetUserRoleByOrg), ctx, tx, userID, orgID, status)
}

// LegacySetUserRoleByOrg mocks base method.
func (m *MockRoleDaoIface) LegacySetUserRoleByOrg(ctx context.Context, tx *gorm.DB, userID, orgID uint64, role string) (*entity.RoleBinding, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LegacySetUserRoleByOrg", ctx, tx, userID, orgID, role)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// LegacySetUserRoleByOrg indicates an expected call of LegacySetUserRoleByOrg.
func (mr *MockRoleDaoIfaceMockRecorder) LegacySetUserRoleByOrg(ctx, tx, userID, orgID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LegacySetUserRoleByOrg", reflect.TypeOf((*MockRoleDaoIface)(nil).LegacySetUserRoleByOrg), ctx, tx, userID, orgID, role)
}

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

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

// ListProjectRolesByUserID mocks base method.
func (m *MockRoleDaoIface) ListProjectRolesByUserID(ctx context.Context, tx *gorm.DB, userID uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectRolesByUserID", ctx, tx, userID, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectRolesByUserID indicates an expected call of ListProjectRolesByUserID.
func (mr *MockRoleDaoIfaceMockRecorder) ListProjectRolesByUserID(ctx, tx, userID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectRolesByUserID", reflect.TypeOf((*MockRoleDaoIface)(nil).ListProjectRolesByUserID), ctx, tx, userID, status)
}

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

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

// ListRolesByScope mocks base method.
func (m *MockRoleDaoIface) ListRolesByScope(ctx context.Context, tx *gorm.DB, scopeType ScopeType, scopeID uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRolesByScope", ctx, tx, scopeType, scopeID, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRolesByScope indicates an expected call of ListRolesByScope.
func (mr *MockRoleDaoIfaceMockRecorder) ListRolesByScope(ctx, tx, scopeType, scopeID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesByScope", reflect.TypeOf((*MockRoleDaoIface)(nil).ListRolesByScope), ctx, tx, scopeType, scopeID, status)
}

// ListRolesByScopeOnTargetList mocks base method.
func (m *MockRoleDaoIface) ListRolesByScopeOnTargetList(ctx context.Context, tx *gorm.DB, scopeType ScopeType, scopeID uint64, targetType TargetType, targetIDs []uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRolesByScopeOnTargetList", ctx, tx, scopeType, scopeID, targetType, targetIDs, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRolesByScopeOnTargetList indicates an expected call of ListRolesByScopeOnTargetList.
func (mr *MockRoleDaoIfaceMockRecorder) ListRolesByScopeOnTargetList(ctx, tx, scopeType, scopeID, targetType, targetIDs, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesByScopeOnTargetList", reflect.TypeOf((*MockRoleDaoIface)(nil).ListRolesByScopeOnTargetList), ctx, tx, scopeType, scopeID, targetType, targetIDs, status)
}

// ListRolesByTarget mocks base method.
func (m *MockRoleDaoIface) ListRolesByTarget(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRolesByTarget", ctx, tx, targetType, targetID, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRolesByTarget indicates an expected call of ListRolesByTarget.
func (mr *MockRoleDaoIfaceMockRecorder) ListRolesByTarget(ctx, tx, targetType, targetID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesByTarget", reflect.TypeOf((*MockRoleDaoIface)(nil).ListRolesByTarget), ctx, tx, targetType, targetID, status)
}

// ListRolesByTargetAndScope mocks base method.
func (m *MockRoleDaoIface) ListRolesByTargetAndScope(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRolesByTargetAndScope", ctx, tx, targetType, targetID, scopeType, scopeID, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRolesByTargetAndScope indicates an expected call of ListRolesByTargetAndScope.
func (mr *MockRoleDaoIfaceMockRecorder) ListRolesByTargetAndScope(ctx, tx, targetType, targetID, scopeType, scopeID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesByTargetAndScope", reflect.TypeOf((*MockRoleDaoIface)(nil).ListRolesByTargetAndScope), ctx, tx, targetType, targetID, scopeType, scopeID, status)
}

// ListRolesByTargetOnScopeList mocks base method.
func (m *MockRoleDaoIface) ListRolesByTargetOnScopeList(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeIDs []uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRolesByTargetOnScopeList", ctx, tx, targetType, targetID, scopeType, scopeIDs, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRolesByTargetOnScopeList indicates an expected call of ListRolesByTargetOnScopeList.
func (mr *MockRoleDaoIfaceMockRecorder) ListRolesByTargetOnScopeList(ctx, tx, targetType, targetID, scopeType, scopeIDs, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesByTargetOnScopeList", reflect.TypeOf((*MockRoleDaoIface)(nil).ListRolesByTargetOnScopeList), ctx, tx, targetType, targetID, scopeType, scopeIDs, status)
}

// ListUserRolesByProject mocks base method.
func (m *MockRoleDaoIface) ListUserRolesByProject(ctx context.Context, tx *gorm.DB, projectID uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserRolesByProject", ctx, tx, projectID, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserRolesByProject indicates an expected call of ListUserRolesByProject.
func (mr *MockRoleDaoIfaceMockRecorder) ListUserRolesByProject(ctx, tx, projectID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserRolesByProject", reflect.TypeOf((*MockRoleDaoIface)(nil).ListUserRolesByProject), ctx, tx, projectID, status)
}

// ListUserRolesByProjects mocks base method.
func (m *MockRoleDaoIface) ListUserRolesByProjects(ctx context.Context, tx *gorm.DB, userID uint64, projectIDs []uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserRolesByProjects", ctx, tx, userID, projectIDs, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserRolesByProjects indicates an expected call of ListUserRolesByProjects.
func (mr *MockRoleDaoIfaceMockRecorder) ListUserRolesByProjects(ctx, tx, userID, projectIDs, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserRolesByProjects", reflect.TypeOf((*MockRoleDaoIface)(nil).ListUserRolesByProjects), ctx, tx, userID, projectIDs, status)
}

// ListUserRolesByUserIDAndOrg mocks base method.
func (m *MockRoleDaoIface) ListUserRolesByUserIDAndOrg(ctx context.Context, tx *gorm.DB, userID, orgID uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserRolesByUserIDAndOrg", ctx, tx, userID, orgID, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserRolesByUserIDAndOrg indicates an expected call of ListUserRolesByUserIDAndOrg.
func (mr *MockRoleDaoIfaceMockRecorder) ListUserRolesByUserIDAndOrg(ctx, tx, userID, orgID, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserRolesByUserIDAndOrg", reflect.TypeOf((*MockRoleDaoIface)(nil).ListUserRolesByUserIDAndOrg), ctx, tx, userID, orgID, status)
}

// ListUserRolesByUserIDAndOrgs mocks base method.
func (m *MockRoleDaoIface) ListUserRolesByUserIDAndOrgs(ctx context.Context, tx *gorm.DB, userID uint64, orgIDs []uint64, status []string) ([]entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserRolesByUserIDAndOrgs", ctx, tx, userID, orgIDs, status)
	ret0, _ := ret[0].([]entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserRolesByUserIDAndOrgs indicates an expected call of ListUserRolesByUserIDAndOrgs.
func (mr *MockRoleDaoIfaceMockRecorder) ListUserRolesByUserIDAndOrgs(ctx, tx, userID, orgIDs, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserRolesByUserIDAndOrgs", reflect.TypeOf((*MockRoleDaoIface)(nil).ListUserRolesByUserIDAndOrgs), ctx, tx, userID, orgIDs, status)
}

// RemoveOrgRoleForUser mocks base method.
func (m *MockRoleDaoIface) RemoveOrgRoleForUser(ctx context.Context, tx *gorm.DB, userID, orgID uint64, role string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveOrgRoleForUser", ctx, tx, userID, orgID, role)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveOrgRoleForUser indicates an expected call of RemoveOrgRoleForUser.
func (mr *MockRoleDaoIfaceMockRecorder) RemoveOrgRoleForUser(ctx, tx, userID, orgID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveOrgRoleForUser", reflect.TypeOf((*MockRoleDaoIface)(nil).RemoveOrgRoleForUser), ctx, tx, userID, orgID, role)
}

// RemoveProjectRoleForUser mocks base method.
func (m *MockRoleDaoIface) RemoveProjectRoleForUser(ctx context.Context, tx *gorm.DB, userID, projectID uint64, role string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveProjectRoleForUser", ctx, tx, userID, projectID, role)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveProjectRoleForUser indicates an expected call of RemoveProjectRoleForUser.
func (mr *MockRoleDaoIfaceMockRecorder) RemoveProjectRoleForUser(ctx, tx, userID, projectID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProjectRoleForUser", reflect.TypeOf((*MockRoleDaoIface)(nil).RemoveProjectRoleForUser), ctx, tx, userID, projectID, role)
}

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

// SaveDataAppRoleBindingsToDynamodbByApiKeyID indicates an expected call of SaveDataAppRoleBindingsToDynamodbByApiKeyID.
func (mr *MockRoleDaoIfaceMockRecorder) SaveDataAppRoleBindingsToDynamodbByApiKeyID(ctx, tx, ddb, apiKeyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveDataAppRoleBindingsToDynamodbByApiKeyID", reflect.TypeOf((*MockRoleDaoIface)(nil).SaveDataAppRoleBindingsToDynamodbByApiKeyID), ctx, tx, ddb, apiKeyID)
}

// UpdateRoleBindingByID mocks base method.
func (m *MockRoleDaoIface) UpdateRoleBindingByID(ctx context.Context, tx *gorm.DB, binding entity.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRoleBindingByID", ctx, tx, binding)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateRoleOrStatus mocks base method.
func (m *MockRoleDaoIface) UpdateRoleOrStatus(ctx context.Context, tx *gorm.DB, binding entity.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRoleOrStatus", ctx, tx, binding)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// UpsertRole mocks base method.
func (m *MockRoleDaoIface) UpsertRole(ctx context.Context, tx *gorm.DB, targetType TargetType, targetID uint64, scopeType ScopeType, scopeID uint64, role, status string) (*entity.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertRole", ctx, tx, targetType, targetID, scopeType, scopeID, role, status)
	ret0, _ := ret[0].(*entity.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertRole indicates an expected call of UpsertRole.
func (mr *MockRoleDaoIfaceMockRecorder) UpsertRole(ctx, tx, targetType, targetID, scopeType, scopeID, role, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRole", reflect.TypeOf((*MockRoleDaoIface)(nil).UpsertRole), ctx, tx, targetType, targetID, scopeType, scopeID, role, status)
}