package mock_controller

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	controller "github.com/solo-io/external-apis/pkg/api/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) 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)
}

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

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) FinalizeRoleBinding(obj *v1.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockRoleBindingFinalizerMockRecorder) FinalizeRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeRoleBinding", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).FinalizeRoleBinding), obj)
}

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
}

func (mr *MockRoleBindingFinalizerMockRecorder) RoleBindingFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleBindingFinalizerName", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).RoleBindingFinalizerName))
}

type MockRoleBindingReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingReconcileLoopMockRecorder
}

type MockRoleBindingReconcileLoopMockRecorder struct {
	mock *MockRoleBindingReconcileLoop
}

func NewMockRoleBindingReconcileLoop(ctrl *gomock.Controller) *MockRoleBindingReconcileLoop {
	mock := &MockRoleBindingReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockRoleBindingReconcileLoopMockRecorder{mock}
	return mock
}

func (m *MockRoleBindingReconcileLoop) EXPECT() *MockRoleBindingReconcileLoopMockRecorder {
	return m.recorder
}

func (m *MockRoleBindingReconcileLoop) RunRoleBindingReconciler(ctx context.Context, rec controller.RoleBindingReconciler, 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, "RunRoleBindingReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockRoleBindingReconcileLoopMockRecorder) RunRoleBindingReconciler(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, "RunRoleBindingReconciler", reflect.TypeOf((*MockRoleBindingReconcileLoop)(nil).RunRoleBindingReconciler), varargs...)
}

type MockClusterRoleReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleReconcilerMockRecorder
}

type MockClusterRoleReconcilerMockRecorder struct {
	mock *MockClusterRoleReconciler
}

func NewMockClusterRoleReconciler(ctrl *gomock.Controller) *MockClusterRoleReconciler {
	mock := &MockClusterRoleReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleReconcilerMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleReconciler) EXPECT() *MockClusterRoleReconcilerMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleReconciler) ReconcileClusterRole(obj *v1.ClusterRole) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRole", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockClusterRoleReconcilerMockRecorder) ReconcileClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRole", reflect.TypeOf((*MockClusterRoleReconciler)(nil).ReconcileClusterRole), obj)
}

type MockClusterRoleDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleDeletionReconcilerMockRecorder
}

type MockClusterRoleDeletionReconcilerMockRecorder struct {
	mock *MockClusterRoleDeletionReconciler
}

func NewMockClusterRoleDeletionReconciler(ctrl *gomock.Controller) *MockClusterRoleDeletionReconciler {
	mock := &MockClusterRoleDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleDeletionReconcilerMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleDeletionReconciler) EXPECT() *MockClusterRoleDeletionReconcilerMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleDeletionReconciler) ReconcileClusterRoleDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockClusterRoleDeletionReconcilerMockRecorder) ReconcileClusterRoleDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleDeletion", reflect.TypeOf((*MockClusterRoleDeletionReconciler)(nil).ReconcileClusterRoleDeletion), req)
}

type MockClusterRoleFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleFinalizerMockRecorder
}

type MockClusterRoleFinalizerMockRecorder struct {
	mock *MockClusterRoleFinalizer
}

func NewMockClusterRoleFinalizer(ctrl *gomock.Controller) *MockClusterRoleFinalizer {
	mock := &MockClusterRoleFinalizer{ctrl: ctrl}
	mock.recorder = &MockClusterRoleFinalizerMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleFinalizer) EXPECT() *MockClusterRoleFinalizerMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleFinalizer) ClusterRoleFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterRoleFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}

func (mr *MockClusterRoleFinalizerMockRecorder) ClusterRoleFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterRoleFinalizerName", reflect.TypeOf((*MockClusterRoleFinalizer)(nil).ClusterRoleFinalizerName))
}

func (m *MockClusterRoleFinalizer) FinalizeClusterRole(obj *v1.ClusterRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeClusterRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockClusterRoleFinalizerMockRecorder) FinalizeClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeClusterRole", reflect.TypeOf((*MockClusterRoleFinalizer)(nil).FinalizeClusterRole), obj)
}

func (m *MockClusterRoleFinalizer) ReconcileClusterRole(obj *v1.ClusterRole) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRole", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockClusterRoleFinalizerMockRecorder) ReconcileClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRole", reflect.TypeOf((*MockClusterRoleFinalizer)(nil).ReconcileClusterRole), obj)
}

type MockClusterRoleReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleReconcileLoopMockRecorder
}

type MockClusterRoleReconcileLoopMockRecorder struct {
	mock *MockClusterRoleReconcileLoop
}

func NewMockClusterRoleReconcileLoop(ctrl *gomock.Controller) *MockClusterRoleReconcileLoop {
	mock := &MockClusterRoleReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockClusterRoleReconcileLoopMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleReconcileLoop) EXPECT() *MockClusterRoleReconcileLoopMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleReconcileLoop) RunClusterRoleReconciler(ctx context.Context, rec controller.ClusterRoleReconciler, 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, "RunClusterRoleReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockClusterRoleReconcileLoopMockRecorder) RunClusterRoleReconciler(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, "RunClusterRoleReconciler", reflect.TypeOf((*MockClusterRoleReconcileLoop)(nil).RunClusterRoleReconciler), varargs...)
}

type MockClusterRoleBindingReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingReconcilerMockRecorder
}

type MockClusterRoleBindingReconcilerMockRecorder struct {
	mock *MockClusterRoleBindingReconciler
}

func NewMockClusterRoleBindingReconciler(ctrl *gomock.Controller) *MockClusterRoleBindingReconciler {
	mock := &MockClusterRoleBindingReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingReconcilerMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleBindingReconciler) EXPECT() *MockClusterRoleBindingReconcilerMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleBindingReconciler) ReconcileClusterRoleBinding(obj *v1.ClusterRoleBinding) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleBinding", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockClusterRoleBindingReconcilerMockRecorder) ReconcileClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingReconciler)(nil).ReconcileClusterRoleBinding), obj)
}

type MockClusterRoleBindingDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingDeletionReconcilerMockRecorder
}

type MockClusterRoleBindingDeletionReconcilerMockRecorder struct {
	mock *MockClusterRoleBindingDeletionReconciler
}

func NewMockClusterRoleBindingDeletionReconciler(ctrl *gomock.Controller) *MockClusterRoleBindingDeletionReconciler {
	mock := &MockClusterRoleBindingDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingDeletionReconcilerMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleBindingDeletionReconciler) EXPECT() *MockClusterRoleBindingDeletionReconcilerMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleBindingDeletionReconciler) ReconcileClusterRoleBindingDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleBindingDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockClusterRoleBindingDeletionReconcilerMockRecorder) ReconcileClusterRoleBindingDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleBindingDeletion", reflect.TypeOf((*MockClusterRoleBindingDeletionReconciler)(nil).ReconcileClusterRoleBindingDeletion), req)
}

type MockClusterRoleBindingFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingFinalizerMockRecorder
}

type MockClusterRoleBindingFinalizerMockRecorder struct {
	mock *MockClusterRoleBindingFinalizer
}

func NewMockClusterRoleBindingFinalizer(ctrl *gomock.Controller) *MockClusterRoleBindingFinalizer {
	mock := &MockClusterRoleBindingFinalizer{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingFinalizerMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleBindingFinalizer) EXPECT() *MockClusterRoleBindingFinalizerMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleBindingFinalizer) ClusterRoleBindingFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterRoleBindingFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}

func (mr *MockClusterRoleBindingFinalizerMockRecorder) ClusterRoleBindingFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterRoleBindingFinalizerName", reflect.TypeOf((*MockClusterRoleBindingFinalizer)(nil).ClusterRoleBindingFinalizerName))
}

func (m *MockClusterRoleBindingFinalizer) FinalizeClusterRoleBinding(obj *v1.ClusterRoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeClusterRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockClusterRoleBindingFinalizerMockRecorder) FinalizeClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingFinalizer)(nil).FinalizeClusterRoleBinding), obj)
}

func (m *MockClusterRoleBindingFinalizer) ReconcileClusterRoleBinding(obj *v1.ClusterRoleBinding) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleBinding", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockClusterRoleBindingFinalizerMockRecorder) ReconcileClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingFinalizer)(nil).ReconcileClusterRoleBinding), obj)
}

type MockClusterRoleBindingReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingReconcileLoopMockRecorder
}

type MockClusterRoleBindingReconcileLoopMockRecorder struct {
	mock *MockClusterRoleBindingReconcileLoop
}

func NewMockClusterRoleBindingReconcileLoop(ctrl *gomock.Controller) *MockClusterRoleBindingReconcileLoop {
	mock := &MockClusterRoleBindingReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingReconcileLoopMockRecorder{mock}
	return mock
}

func (m *MockClusterRoleBindingReconcileLoop) EXPECT() *MockClusterRoleBindingReconcileLoopMockRecorder {
	return m.recorder
}

func (m *MockClusterRoleBindingReconcileLoop) RunClusterRoleBindingReconciler(ctx context.Context, rec controller.ClusterRoleBindingReconciler, 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, "RunClusterRoleBindingReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockClusterRoleBindingReconcileLoopMockRecorder) RunClusterRoleBindingReconciler(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, "RunClusterRoleBindingReconciler", reflect.TypeOf((*MockClusterRoleBindingReconcileLoop)(nil).RunClusterRoleBindingReconciler), varargs...)
}
// Code generated by MockGen. DO NOT EDIT.
// Source: ./reconcilers.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	controller "github.com/solo-io/external-apis/pkg/api/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"
)

// MockRoleReconciler is a mock of RoleReconciler interface.
type MockRoleReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleReconcilerMockRecorder
}

// MockRoleReconcilerMockRecorder is the mock recorder for MockRoleReconciler.
type MockRoleReconcilerMockRecorder struct {
	mock *MockRoleReconciler
}

// NewMockRoleReconciler creates a new mock instance.
func NewMockRoleReconciler(ctrl *gomock.Controller) *MockRoleReconciler {
	mock := &MockRoleReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileRole mocks base method.
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
}

// ReconcileRole indicates an expected call of ReconcileRole.
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)
}

// MockRoleDeletionReconciler is a mock of RoleDeletionReconciler interface.
type MockRoleDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleDeletionReconcilerMockRecorder
}

// MockRoleDeletionReconcilerMockRecorder is the mock recorder for MockRoleDeletionReconciler.
type MockRoleDeletionReconcilerMockRecorder struct {
	mock *MockRoleDeletionReconciler
}

// NewMockRoleDeletionReconciler creates a new mock instance.
func NewMockRoleDeletionReconciler(ctrl *gomock.Controller) *MockRoleDeletionReconciler {
	mock := &MockRoleDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileRoleDeletion mocks base method.
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
}

// ReconcileRoleDeletion indicates an expected call of ReconcileRoleDeletion.
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)
}

// MockRoleFinalizer is a mock of RoleFinalizer interface.
type MockRoleFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockRoleFinalizerMockRecorder
}

// MockRoleFinalizerMockRecorder is the mock recorder for MockRoleFinalizer.
type MockRoleFinalizerMockRecorder struct {
	mock *MockRoleFinalizer
}

// NewMockRoleFinalizer creates a new mock instance.
func NewMockRoleFinalizer(ctrl *gomock.Controller) *MockRoleFinalizer {
	mock := &MockRoleFinalizer{ctrl: ctrl}
	mock.recorder = &MockRoleFinalizerMockRecorder{mock}
	return mock
}

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

// FinalizeRole mocks base method.
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
}

// FinalizeRole indicates an expected call of FinalizeRole.
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)
}

// ReconcileRole mocks base method.
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
}

// ReconcileRole indicates an expected call of ReconcileRole.
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)
}

// RoleFinalizerName mocks base method.
func (m *MockRoleFinalizer) RoleFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoleFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}

// RoleFinalizerName indicates an expected call of RoleFinalizerName.
func (mr *MockRoleFinalizerMockRecorder) RoleFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleFinalizerName", reflect.TypeOf((*MockRoleFinalizer)(nil).RoleFinalizerName))
}

// MockRoleReconcileLoop is a mock of RoleReconcileLoop interface.
type MockRoleReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockRoleReconcileLoopMockRecorder
}

// MockRoleReconcileLoopMockRecorder is the mock recorder for MockRoleReconcileLoop.
type MockRoleReconcileLoopMockRecorder struct {
	mock *MockRoleReconcileLoop
}

// NewMockRoleReconcileLoop creates a new mock instance.
func NewMockRoleReconcileLoop(ctrl *gomock.Controller) *MockRoleReconcileLoop {
	mock := &MockRoleReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockRoleReconcileLoopMockRecorder{mock}
	return mock
}

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

// RunRoleReconciler mocks base method.
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
}

// RunRoleReconciler indicates an expected call of RunRoleReconciler.
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...)
}

// MockRoleBindingReconciler is a mock of RoleBindingReconciler interface.
type MockRoleBindingReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingReconcilerMockRecorder
}

// MockRoleBindingReconcilerMockRecorder is the mock recorder for MockRoleBindingReconciler.
type MockRoleBindingReconcilerMockRecorder struct {
	mock *MockRoleBindingReconciler
}

// NewMockRoleBindingReconciler creates a new mock instance.
func NewMockRoleBindingReconciler(ctrl *gomock.Controller) *MockRoleBindingReconciler {
	mock := &MockRoleBindingReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleBindingReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileRoleBinding mocks base method.
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
}

// ReconcileRoleBinding indicates an expected call of ReconcileRoleBinding.
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)
}

// MockRoleBindingDeletionReconciler is a mock of RoleBindingDeletionReconciler interface.
type MockRoleBindingDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingDeletionReconcilerMockRecorder
}

// MockRoleBindingDeletionReconcilerMockRecorder is the mock recorder for MockRoleBindingDeletionReconciler.
type MockRoleBindingDeletionReconcilerMockRecorder struct {
	mock *MockRoleBindingDeletionReconciler
}

// NewMockRoleBindingDeletionReconciler creates a new mock instance.
func NewMockRoleBindingDeletionReconciler(ctrl *gomock.Controller) *MockRoleBindingDeletionReconciler {
	mock := &MockRoleBindingDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockRoleBindingDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileRoleBindingDeletion mocks base method.
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
}

// ReconcileRoleBindingDeletion indicates an expected call of ReconcileRoleBindingDeletion.
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)
}

// MockRoleBindingFinalizer is a mock of RoleBindingFinalizer interface.
type MockRoleBindingFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingFinalizerMockRecorder
}

// MockRoleBindingFinalizerMockRecorder is the mock recorder for MockRoleBindingFinalizer.
type MockRoleBindingFinalizerMockRecorder struct {
	mock *MockRoleBindingFinalizer
}

// NewMockRoleBindingFinalizer creates a new mock instance.
func NewMockRoleBindingFinalizer(ctrl *gomock.Controller) *MockRoleBindingFinalizer {
	mock := &MockRoleBindingFinalizer{ctrl: ctrl}
	mock.recorder = &MockRoleBindingFinalizerMockRecorder{mock}
	return mock
}

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

// FinalizeRoleBinding mocks base method.
func (m *MockRoleBindingFinalizer) FinalizeRoleBinding(obj *v1.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// FinalizeRoleBinding indicates an expected call of FinalizeRoleBinding.
func (mr *MockRoleBindingFinalizerMockRecorder) FinalizeRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeRoleBinding", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).FinalizeRoleBinding), obj)
}

// ReconcileRoleBinding mocks base method.
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
}

// ReconcileRoleBinding indicates an expected call of ReconcileRoleBinding.
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)
}

// RoleBindingFinalizerName mocks base method.
func (m *MockRoleBindingFinalizer) RoleBindingFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoleBindingFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}

// RoleBindingFinalizerName indicates an expected call of RoleBindingFinalizerName.
func (mr *MockRoleBindingFinalizerMockRecorder) RoleBindingFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleBindingFinalizerName", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).RoleBindingFinalizerName))
}

// MockRoleBindingReconcileLoop is a mock of RoleBindingReconcileLoop interface.
type MockRoleBindingReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingReconcileLoopMockRecorder
}

// MockRoleBindingReconcileLoopMockRecorder is the mock recorder for MockRoleBindingReconcileLoop.
type MockRoleBindingReconcileLoopMockRecorder struct {
	mock *MockRoleBindingReconcileLoop
}

// NewMockRoleBindingReconcileLoop creates a new mock instance.
func NewMockRoleBindingReconcileLoop(ctrl *gomock.Controller) *MockRoleBindingReconcileLoop {
	mock := &MockRoleBindingReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockRoleBindingReconcileLoopMockRecorder{mock}
	return mock
}

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

// RunRoleBindingReconciler mocks base method.
func (m *MockRoleBindingReconcileLoop) RunRoleBindingReconciler(ctx context.Context, rec controller.RoleBindingReconciler, 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, "RunRoleBindingReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunRoleBindingReconciler indicates an expected call of RunRoleBindingReconciler.
func (mr *MockRoleBindingReconcileLoopMockRecorder) RunRoleBindingReconciler(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, "RunRoleBindingReconciler", reflect.TypeOf((*MockRoleBindingReconcileLoop)(nil).RunRoleBindingReconciler), varargs...)
}

// MockClusterRoleReconciler is a mock of ClusterRoleReconciler interface.
type MockClusterRoleReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleReconcilerMockRecorder
}

// MockClusterRoleReconcilerMockRecorder is the mock recorder for MockClusterRoleReconciler.
type MockClusterRoleReconcilerMockRecorder struct {
	mock *MockClusterRoleReconciler
}

// NewMockClusterRoleReconciler creates a new mock instance.
func NewMockClusterRoleReconciler(ctrl *gomock.Controller) *MockClusterRoleReconciler {
	mock := &MockClusterRoleReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileClusterRole mocks base method.
func (m *MockClusterRoleReconciler) ReconcileClusterRole(obj *v1.ClusterRole) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRole", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileClusterRole indicates an expected call of ReconcileClusterRole.
func (mr *MockClusterRoleReconcilerMockRecorder) ReconcileClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRole", reflect.TypeOf((*MockClusterRoleReconciler)(nil).ReconcileClusterRole), obj)
}

// MockClusterRoleDeletionReconciler is a mock of ClusterRoleDeletionReconciler interface.
type MockClusterRoleDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleDeletionReconcilerMockRecorder
}

// MockClusterRoleDeletionReconcilerMockRecorder is the mock recorder for MockClusterRoleDeletionReconciler.
type MockClusterRoleDeletionReconcilerMockRecorder struct {
	mock *MockClusterRoleDeletionReconciler
}

// NewMockClusterRoleDeletionReconciler creates a new mock instance.
func NewMockClusterRoleDeletionReconciler(ctrl *gomock.Controller) *MockClusterRoleDeletionReconciler {
	mock := &MockClusterRoleDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileClusterRoleDeletion mocks base method.
func (m *MockClusterRoleDeletionReconciler) ReconcileClusterRoleDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileClusterRoleDeletion indicates an expected call of ReconcileClusterRoleDeletion.
func (mr *MockClusterRoleDeletionReconcilerMockRecorder) ReconcileClusterRoleDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleDeletion", reflect.TypeOf((*MockClusterRoleDeletionReconciler)(nil).ReconcileClusterRoleDeletion), req)
}

// MockClusterRoleFinalizer is a mock of ClusterRoleFinalizer interface.
type MockClusterRoleFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleFinalizerMockRecorder
}

// MockClusterRoleFinalizerMockRecorder is the mock recorder for MockClusterRoleFinalizer.
type MockClusterRoleFinalizerMockRecorder struct {
	mock *MockClusterRoleFinalizer
}

// NewMockClusterRoleFinalizer creates a new mock instance.
func NewMockClusterRoleFinalizer(ctrl *gomock.Controller) *MockClusterRoleFinalizer {
	mock := &MockClusterRoleFinalizer{ctrl: ctrl}
	mock.recorder = &MockClusterRoleFinalizerMockRecorder{mock}
	return mock
}

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

// ClusterRoleFinalizerName mocks base method.
func (m *MockClusterRoleFinalizer) ClusterRoleFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterRoleFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}

// ClusterRoleFinalizerName indicates an expected call of ClusterRoleFinalizerName.
func (mr *MockClusterRoleFinalizerMockRecorder) ClusterRoleFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterRoleFinalizerName", reflect.TypeOf((*MockClusterRoleFinalizer)(nil).ClusterRoleFinalizerName))
}

// FinalizeClusterRole mocks base method.
func (m *MockClusterRoleFinalizer) FinalizeClusterRole(obj *v1.ClusterRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeClusterRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// FinalizeClusterRole indicates an expected call of FinalizeClusterRole.
func (mr *MockClusterRoleFinalizerMockRecorder) FinalizeClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeClusterRole", reflect.TypeOf((*MockClusterRoleFinalizer)(nil).FinalizeClusterRole), obj)
}

// ReconcileClusterRole mocks base method.
func (m *MockClusterRoleFinalizer) ReconcileClusterRole(obj *v1.ClusterRole) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRole", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileClusterRole indicates an expected call of ReconcileClusterRole.
func (mr *MockClusterRoleFinalizerMockRecorder) ReconcileClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRole", reflect.TypeOf((*MockClusterRoleFinalizer)(nil).ReconcileClusterRole), obj)
}

// MockClusterRoleReconcileLoop is a mock of ClusterRoleReconcileLoop interface.
type MockClusterRoleReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleReconcileLoopMockRecorder
}

// MockClusterRoleReconcileLoopMockRecorder is the mock recorder for MockClusterRoleReconcileLoop.
type MockClusterRoleReconcileLoopMockRecorder struct {
	mock *MockClusterRoleReconcileLoop
}

// NewMockClusterRoleReconcileLoop creates a new mock instance.
func NewMockClusterRoleReconcileLoop(ctrl *gomock.Controller) *MockClusterRoleReconcileLoop {
	mock := &MockClusterRoleReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockClusterRoleReconcileLoopMockRecorder{mock}
	return mock
}

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

// RunClusterRoleReconciler mocks base method.
func (m *MockClusterRoleReconcileLoop) RunClusterRoleReconciler(ctx context.Context, rec controller.ClusterRoleReconciler, 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, "RunClusterRoleReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunClusterRoleReconciler indicates an expected call of RunClusterRoleReconciler.
func (mr *MockClusterRoleReconcileLoopMockRecorder) RunClusterRoleReconciler(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, "RunClusterRoleReconciler", reflect.TypeOf((*MockClusterRoleReconcileLoop)(nil).RunClusterRoleReconciler), varargs...)
}

// MockClusterRoleBindingReconciler is a mock of ClusterRoleBindingReconciler interface.
type MockClusterRoleBindingReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingReconcilerMockRecorder
}

// MockClusterRoleBindingReconcilerMockRecorder is the mock recorder for MockClusterRoleBindingReconciler.
type MockClusterRoleBindingReconcilerMockRecorder struct {
	mock *MockClusterRoleBindingReconciler
}

// NewMockClusterRoleBindingReconciler creates a new mock instance.
func NewMockClusterRoleBindingReconciler(ctrl *gomock.Controller) *MockClusterRoleBindingReconciler {
	mock := &MockClusterRoleBindingReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileClusterRoleBinding mocks base method.
func (m *MockClusterRoleBindingReconciler) ReconcileClusterRoleBinding(obj *v1.ClusterRoleBinding) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleBinding", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileClusterRoleBinding indicates an expected call of ReconcileClusterRoleBinding.
func (mr *MockClusterRoleBindingReconcilerMockRecorder) ReconcileClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingReconciler)(nil).ReconcileClusterRoleBinding), obj)
}

// MockClusterRoleBindingDeletionReconciler is a mock of ClusterRoleBindingDeletionReconciler interface.
type MockClusterRoleBindingDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingDeletionReconcilerMockRecorder
}

// MockClusterRoleBindingDeletionReconcilerMockRecorder is the mock recorder for MockClusterRoleBindingDeletionReconciler.
type MockClusterRoleBindingDeletionReconcilerMockRecorder struct {
	mock *MockClusterRoleBindingDeletionReconciler
}

// NewMockClusterRoleBindingDeletionReconciler creates a new mock instance.
func NewMockClusterRoleBindingDeletionReconciler(ctrl *gomock.Controller) *MockClusterRoleBindingDeletionReconciler {
	mock := &MockClusterRoleBindingDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileClusterRoleBindingDeletion mocks base method.
func (m *MockClusterRoleBindingDeletionReconciler) ReconcileClusterRoleBindingDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleBindingDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileClusterRoleBindingDeletion indicates an expected call of ReconcileClusterRoleBindingDeletion.
func (mr *MockClusterRoleBindingDeletionReconcilerMockRecorder) ReconcileClusterRoleBindingDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleBindingDeletion", reflect.TypeOf((*MockClusterRoleBindingDeletionReconciler)(nil).ReconcileClusterRoleBindingDeletion), req)
}

// MockClusterRoleBindingFinalizer is a mock of ClusterRoleBindingFinalizer interface.
type MockClusterRoleBindingFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingFinalizerMockRecorder
}

// MockClusterRoleBindingFinalizerMockRecorder is the mock recorder for MockClusterRoleBindingFinalizer.
type MockClusterRoleBindingFinalizerMockRecorder struct {
	mock *MockClusterRoleBindingFinalizer
}

// NewMockClusterRoleBindingFinalizer creates a new mock instance.
func NewMockClusterRoleBindingFinalizer(ctrl *gomock.Controller) *MockClusterRoleBindingFinalizer {
	mock := &MockClusterRoleBindingFinalizer{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingFinalizerMockRecorder{mock}
	return mock
}

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

// ClusterRoleBindingFinalizerName mocks base method.
func (m *MockClusterRoleBindingFinalizer) ClusterRoleBindingFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterRoleBindingFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}

// ClusterRoleBindingFinalizerName indicates an expected call of ClusterRoleBindingFinalizerName.
func (mr *MockClusterRoleBindingFinalizerMockRecorder) ClusterRoleBindingFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterRoleBindingFinalizerName", reflect.TypeOf((*MockClusterRoleBindingFinalizer)(nil).ClusterRoleBindingFinalizerName))
}

// FinalizeClusterRoleBinding mocks base method.
func (m *MockClusterRoleBindingFinalizer) FinalizeClusterRoleBinding(obj *v1.ClusterRoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeClusterRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// FinalizeClusterRoleBinding indicates an expected call of FinalizeClusterRoleBinding.
func (mr *MockClusterRoleBindingFinalizerMockRecorder) FinalizeClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingFinalizer)(nil).FinalizeClusterRoleBinding), obj)
}

// ReconcileClusterRoleBinding mocks base method.
func (m *MockClusterRoleBindingFinalizer) ReconcileClusterRoleBinding(obj *v1.ClusterRoleBinding) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterRoleBinding", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileClusterRoleBinding indicates an expected call of ReconcileClusterRoleBinding.
func (mr *MockClusterRoleBindingFinalizerMockRecorder) ReconcileClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingFinalizer)(nil).ReconcileClusterRoleBinding), obj)
}

// MockClusterRoleBindingReconcileLoop is a mock of ClusterRoleBindingReconcileLoop interface.
type MockClusterRoleBindingReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingReconcileLoopMockRecorder
}

// MockClusterRoleBindingReconcileLoopMockRecorder is the mock recorder for MockClusterRoleBindingReconcileLoop.
type MockClusterRoleBindingReconcileLoopMockRecorder struct {
	mock *MockClusterRoleBindingReconcileLoop
}

// NewMockClusterRoleBindingReconcileLoop creates a new mock instance.
func NewMockClusterRoleBindingReconcileLoop(ctrl *gomock.Controller) *MockClusterRoleBindingReconcileLoop {
	mock := &MockClusterRoleBindingReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingReconcileLoopMockRecorder{mock}
	return mock
}

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

// RunClusterRoleBindingReconciler mocks base method.
func (m *MockClusterRoleBindingReconcileLoop) RunClusterRoleBindingReconciler(ctx context.Context, rec controller.ClusterRoleBindingReconciler, 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, "RunClusterRoleBindingReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunClusterRoleBindingReconciler indicates an expected call of RunClusterRoleBindingReconciler.
func (mr *MockClusterRoleBindingReconcileLoopMockRecorder) RunClusterRoleBindingReconciler(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, "RunClusterRoleBindingReconciler", reflect.TypeOf((*MockClusterRoleBindingReconcileLoop)(nil).RunClusterRoleBindingReconciler), varargs...)
}
