func (mr *MockRoleBindingFinalizerMockRecorder) RoleBindingFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleBindingFinalizerName", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).RoleBindingFinalizerName))
}
RoleBindingFinalizerName indicates an expected call of RoleBindingFinalizerName
package mock_controller
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	controller "github.com/solo-io/skv2/pkg/multicluster/internal/k8s/rbac.authorization.k8s.io/v1/controller"
	reconcile "github.com/solo-io/skv2/pkg/reconcile"
	v1 "k8s.io/api/rbac/v1"
	predicate "sigs.k8s.io/controller-runtime/pkg/predicate"
)
type MockRoleReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleReconcilerMockRecorder
}
type MockRoleReconcilerMockRecorder struct {
	mock *MockRoleReconciler
}
func NewMockRoleReconciler(ctrl *gomock.Controller) *MockRoleReconciler {
	mock := &MockRoleReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleReconcilerMockRecorder{mock}
	return mock
}
func (m *MockRoleReconciler) EXPECT() *MockRoleReconcilerMockRecorder {
	return m.recorder
}
func (m *MockRoleReconciler) ReconcileRole(obj *v1.Role) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileRole", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleReconcilerMockRecorder) ReconcileRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileRole", reflect.TypeOf((*MockRoleReconciler)(nil).ReconcileRole), obj)
}
type MockRoleDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleDeletionReconcilerMockRecorder
}
type MockRoleDeletionReconcilerMockRecorder struct {
	mock *MockRoleDeletionReconciler
}
func NewMockRoleDeletionReconciler(ctrl *gomock.Controller) *MockRoleDeletionReconciler {
	mock := &MockRoleDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockRoleDeletionReconciler) EXPECT() *MockRoleDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockRoleDeletionReconciler) ReconcileRoleDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileRoleDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleDeletionReconcilerMockRecorder) ReconcileRoleDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileRoleDeletion", reflect.TypeOf((*MockRoleDeletionReconciler)(nil).ReconcileRoleDeletion), req)
}
type MockRoleFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockRoleFinalizerMockRecorder
}
type MockRoleFinalizerMockRecorder struct {
	mock *MockRoleFinalizer
}
func NewMockRoleFinalizer(ctrl *gomock.Controller) *MockRoleFinalizer {
	mock := &MockRoleFinalizer{ctrl: ctrl}
	mock.recorder = &MockRoleFinalizerMockRecorder{mock}
	return mock
}
func (m *MockRoleFinalizer) EXPECT() *MockRoleFinalizerMockRecorder {
	return m.recorder
}
func (m *MockRoleFinalizer) ReconcileRole(obj *v1.Role) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileRole", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleFinalizerMockRecorder) ReconcileRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileRole", reflect.TypeOf((*MockRoleFinalizer)(nil).ReconcileRole), obj)
}
func (m *MockRoleFinalizer) RoleFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoleFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockRoleFinalizerMockRecorder) RoleFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleFinalizerName", reflect.TypeOf((*MockRoleFinalizer)(nil).RoleFinalizerName))
}
func (m *MockRoleFinalizer) FinalizeRole(obj *v1.Role) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleFinalizerMockRecorder) FinalizeRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeRole", reflect.TypeOf((*MockRoleFinalizer)(nil).FinalizeRole), obj)
}
type MockRoleReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockRoleReconcileLoopMockRecorder
}
type MockRoleReconcileLoopMockRecorder struct {
	mock *MockRoleReconcileLoop
}
func NewMockRoleReconcileLoop(ctrl *gomock.Controller) *MockRoleReconcileLoop {
	mock := &MockRoleReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockRoleReconcileLoopMockRecorder{mock}
	return mock
}
func (m *MockRoleReconcileLoop) EXPECT() *MockRoleReconcileLoopMockRecorder {
	return m.recorder
}
func (m *MockRoleReconcileLoop) RunRoleReconciler(ctx context.Context, rec controller.RoleReconciler, predicates ...predicate.Predicate) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, rec}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunRoleReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleReconcileLoopMockRecorder) RunRoleReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, rec}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunRoleReconciler", reflect.TypeOf((*MockRoleReconcileLoop)(nil).RunRoleReconciler), varargs...)
}
type MockRoleBindingReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingReconcilerMockRecorder
}
type MockRoleBindingReconcilerMockRecorder struct {
	mock *MockRoleBindingReconciler
}
func NewMockRoleBindingReconciler(ctrl *gomock.Controller) *MockRoleBindingReconciler {
	mock := &MockRoleBindingReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleBindingReconcilerMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingReconciler) EXPECT() *MockRoleBindingReconcilerMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingReconciler) ReconcileRoleBinding(obj *v1.RoleBinding) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileRoleBinding", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleBindingReconcilerMockRecorder) ReconcileRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileRoleBinding", reflect.TypeOf((*MockRoleBindingReconciler)(nil).ReconcileRoleBinding), obj)
}
type MockRoleBindingDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingDeletionReconcilerMockRecorder
}
type MockRoleBindingDeletionReconcilerMockRecorder struct {
	mock *MockRoleBindingDeletionReconciler
}
func NewMockRoleBindingDeletionReconciler(ctrl *gomock.Controller) *MockRoleBindingDeletionReconciler {
	mock := &MockRoleBindingDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleBindingDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingDeletionReconciler) EXPECT() *MockRoleBindingDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingDeletionReconciler) ReconcileRoleBindingDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileRoleBindingDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingDeletionReconcilerMockRecorder) ReconcileRoleBindingDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileRoleBindingDeletion", reflect.TypeOf((*MockRoleBindingDeletionReconciler)(nil).ReconcileRoleBindingDeletion), req)
}
type MockRoleBindingFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingFinalizerMockRecorder
}
type MockRoleBindingFinalizerMockRecorder struct {
	mock *MockRoleBindingFinalizer
}
func NewMockRoleBindingFinalizer(ctrl *gomock.Controller) *MockRoleBindingFinalizer {
	mock := &MockRoleBindingFinalizer{ctrl: ctrl}
	mock.recorder = &MockRoleBindingFinalizerMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingFinalizer) EXPECT() *MockRoleBindingFinalizerMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingFinalizer) ReconcileRoleBinding(obj *v1.RoleBinding) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileRoleBinding", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleBindingFinalizerMockRecorder) ReconcileRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileRoleBinding", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).ReconcileRoleBinding), obj)
}
func (m *MockRoleBindingFinalizer) RoleBindingFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoleBindingFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}