func NewMockClusterRoleBindingDeletionReconciler(ctrl *gomock.Controller) *MockClusterRoleBindingDeletionReconciler {
	mock := &MockClusterRoleBindingDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingDeletionReconcilerMockRecorder{mock}
	return mock
}
NewMockClusterRoleBindingDeletionReconciler creates a new mock instance
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
}
func (mr *MockRoleBindingFinalizerMockRecorder) RoleBindingFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleBindingFinalizerName", reflect.TypeOf((*MockRoleBindingFinalizer)(nil).RoleBindingFinalizerName))
}
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)
}
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) 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)
}
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)
}
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
}