func (m *MockNamespaceFinalizer) NamespaceFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NamespaceFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}
NamespaceFinalizerName mocks base method
package mock_controller
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	controller "github.com/solo-io/skv2/pkg/multicluster/internal/k8s/core/v1/controller"
	reconcile "github.com/solo-io/skv2/pkg/reconcile"
	v1 "k8s.io/api/core/v1"
	predicate "sigs.k8s.io/controller-runtime/pkg/predicate"
)
type MockSecretReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockSecretReconcilerMockRecorder
}
type MockSecretReconcilerMockRecorder struct {
	mock *MockSecretReconciler
}
func NewMockSecretReconciler(ctrl *gomock.Controller) *MockSecretReconciler {
	mock := &MockSecretReconciler{ctrl: ctrl}
	mock.recorder = &MockSecretReconcilerMockRecorder{mock}
	return mock
}
func (m *MockSecretReconciler) EXPECT() *MockSecretReconcilerMockRecorder {
	return m.recorder
}
func (m *MockSecretReconciler) ReconcileSecret(obj *v1.Secret) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileSecret", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSecretReconcilerMockRecorder) ReconcileSecret(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileSecret", reflect.TypeOf((*MockSecretReconciler)(nil).ReconcileSecret), obj)
}
type MockSecretDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockSecretDeletionReconcilerMockRecorder
}
type MockSecretDeletionReconcilerMockRecorder struct {
	mock *MockSecretDeletionReconciler
}
func NewMockSecretDeletionReconciler(ctrl *gomock.Controller) *MockSecretDeletionReconciler {
	mock := &MockSecretDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockSecretDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockSecretDeletionReconciler) EXPECT() *MockSecretDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockSecretDeletionReconciler) ReconcileSecretDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileSecretDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretDeletionReconcilerMockRecorder) ReconcileSecretDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileSecretDeletion", reflect.TypeOf((*MockSecretDeletionReconciler)(nil).ReconcileSecretDeletion), req)
}
type MockSecretFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockSecretFinalizerMockRecorder
}
type MockSecretFinalizerMockRecorder struct {
	mock *MockSecretFinalizer
}
func NewMockSecretFinalizer(ctrl *gomock.Controller) *MockSecretFinalizer {
	mock := &MockSecretFinalizer{ctrl: ctrl}
	mock.recorder = &MockSecretFinalizerMockRecorder{mock}
	return mock
}
func (m *MockSecretFinalizer) EXPECT() *MockSecretFinalizerMockRecorder {
	return m.recorder
}
func (m *MockSecretFinalizer) ReconcileSecret(obj *v1.Secret) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileSecret", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSecretFinalizerMockRecorder) ReconcileSecret(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileSecret", reflect.TypeOf((*MockSecretFinalizer)(nil).ReconcileSecret), obj)
}
func (m *MockSecretFinalizer) SecretFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SecretFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockSecretFinalizerMockRecorder) SecretFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretFinalizerName", reflect.TypeOf((*MockSecretFinalizer)(nil).SecretFinalizerName))
}
func (m *MockSecretFinalizer) FinalizeSecret(obj *v1.Secret) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeSecret", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretFinalizerMockRecorder) FinalizeSecret(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeSecret", reflect.TypeOf((*MockSecretFinalizer)(nil).FinalizeSecret), obj)
}
type MockSecretReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockSecretReconcileLoopMockRecorder
}
type MockSecretReconcileLoopMockRecorder struct {
	mock *MockSecretReconcileLoop
}
func NewMockSecretReconcileLoop(ctrl *gomock.Controller) *MockSecretReconcileLoop {
	mock := &MockSecretReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockSecretReconcileLoopMockRecorder{mock}
	return mock
}
func (m *MockSecretReconcileLoop) EXPECT() *MockSecretReconcileLoopMockRecorder {
	return m.recorder
}
func (m *MockSecretReconcileLoop) RunSecretReconciler(ctx context.Context, rec controller.SecretReconciler, 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, "RunSecretReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretReconcileLoopMockRecorder) RunSecretReconciler(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, "RunSecretReconciler", reflect.TypeOf((*MockSecretReconcileLoop)(nil).RunSecretReconciler), varargs...)
}
type MockServiceAccountReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountReconcilerMockRecorder
}
type MockServiceAccountReconcilerMockRecorder struct {
	mock *MockServiceAccountReconciler
}
func NewMockServiceAccountReconciler(ctrl *gomock.Controller) *MockServiceAccountReconciler {
	mock := &MockServiceAccountReconciler{ctrl: ctrl}
	mock.recorder = &MockServiceAccountReconcilerMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountReconciler) EXPECT() *MockServiceAccountReconcilerMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountReconciler) ReconcileServiceAccount(obj *v1.ServiceAccount) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileServiceAccount", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockServiceAccountReconcilerMockRecorder) ReconcileServiceAccount(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileServiceAccount", reflect.TypeOf((*MockServiceAccountReconciler)(nil).ReconcileServiceAccount), obj)
}
type MockServiceAccountDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountDeletionReconcilerMockRecorder
}
type MockServiceAccountDeletionReconcilerMockRecorder struct {
	mock *MockServiceAccountDeletionReconciler
}
func NewMockServiceAccountDeletionReconciler(ctrl *gomock.Controller) *MockServiceAccountDeletionReconciler {
	mock := &MockServiceAccountDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockServiceAccountDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountDeletionReconciler) EXPECT() *MockServiceAccountDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountDeletionReconciler) ReconcileServiceAccountDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileServiceAccountDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountDeletionReconcilerMockRecorder) ReconcileServiceAccountDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileServiceAccountDeletion", reflect.TypeOf((*MockServiceAccountDeletionReconciler)(nil).ReconcileServiceAccountDeletion), req)
}
type MockServiceAccountFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountFinalizerMockRecorder
}
type MockServiceAccountFinalizerMockRecorder struct {
	mock *MockServiceAccountFinalizer
}
func NewMockServiceAccountFinalizer(ctrl *gomock.Controller) *MockServiceAccountFinalizer {
	mock := &MockServiceAccountFinalizer{ctrl: ctrl}
	mock.recorder = &MockServiceAccountFinalizerMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountFinalizer) EXPECT() *MockServiceAccountFinalizerMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountFinalizer) ReconcileServiceAccount(obj *v1.ServiceAccount) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileServiceAccount", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockServiceAccountFinalizerMockRecorder) ReconcileServiceAccount(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileServiceAccount", reflect.TypeOf((*MockServiceAccountFinalizer)(nil).ReconcileServiceAccount), obj)
}
func (m *MockServiceAccountFinalizer) ServiceAccountFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServiceAccountFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockServiceAccountFinalizerMockRecorder) ServiceAccountFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceAccountFinalizerName", reflect.TypeOf((*MockServiceAccountFinalizer)(nil).ServiceAccountFinalizerName))
}
func (m *MockServiceAccountFinalizer) FinalizeServiceAccount(obj *v1.ServiceAccount) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeServiceAccount", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountFinalizerMockRecorder) FinalizeServiceAccount(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeServiceAccount", reflect.TypeOf((*MockServiceAccountFinalizer)(nil).FinalizeServiceAccount), obj)
}
type MockServiceAccountReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountReconcileLoopMockRecorder
}
type MockServiceAccountReconcileLoopMockRecorder struct {
	mock *MockServiceAccountReconcileLoop
}
func NewMockServiceAccountReconcileLoop(ctrl *gomock.Controller) *MockServiceAccountReconcileLoop {
	mock := &MockServiceAccountReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockServiceAccountReconcileLoopMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountReconcileLoop) EXPECT() *MockServiceAccountReconcileLoopMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountReconcileLoop) RunServiceAccountReconciler(ctx context.Context, rec controller.ServiceAccountReconciler, 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, "RunServiceAccountReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountReconcileLoopMockRecorder) RunServiceAccountReconciler(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, "RunServiceAccountReconciler", reflect.TypeOf((*MockServiceAccountReconcileLoop)(nil).RunServiceAccountReconciler), varargs...)
}
type MockNamespaceReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceReconcilerMockRecorder
}
type MockNamespaceReconcilerMockRecorder struct {
	mock *MockNamespaceReconciler
}
func NewMockNamespaceReconciler(ctrl *gomock.Controller) *MockNamespaceReconciler {
	mock := &MockNamespaceReconciler{ctrl: ctrl}
	mock.recorder = &MockNamespaceReconcilerMockRecorder{mock}
	return mock
}
func (m *MockNamespaceReconciler) EXPECT() *MockNamespaceReconcilerMockRecorder {
	return m.recorder
}
func (m *MockNamespaceReconciler) ReconcileNamespace(obj *v1.Namespace) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileNamespace", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNamespaceReconcilerMockRecorder) ReconcileNamespace(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileNamespace", reflect.TypeOf((*MockNamespaceReconciler)(nil).ReconcileNamespace), obj)
}
type MockNamespaceDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceDeletionReconcilerMockRecorder
}
type MockNamespaceDeletionReconcilerMockRecorder struct {
	mock *MockNamespaceDeletionReconciler
}
func NewMockNamespaceDeletionReconciler(ctrl *gomock.Controller) *MockNamespaceDeletionReconciler {
	mock := &MockNamespaceDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockNamespaceDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockNamespaceDeletionReconciler) EXPECT() *MockNamespaceDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockNamespaceDeletionReconciler) ReconcileNamespaceDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileNamespaceDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNamespaceDeletionReconcilerMockRecorder) ReconcileNamespaceDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileNamespaceDeletion", reflect.TypeOf((*MockNamespaceDeletionReconciler)(nil).ReconcileNamespaceDeletion), req)
}
type MockNamespaceFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceFinalizerMockRecorder
}
type MockNamespaceFinalizerMockRecorder struct {
	mock *MockNamespaceFinalizer
}
func NewMockNamespaceFinalizer(ctrl *gomock.Controller) *MockNamespaceFinalizer {
	mock := &MockNamespaceFinalizer{ctrl: ctrl}
	mock.recorder = &MockNamespaceFinalizerMockRecorder{mock}
	return mock
}
func (m *MockNamespaceFinalizer) EXPECT() *MockNamespaceFinalizerMockRecorder {
	return m.recorder
}
func (m *MockNamespaceFinalizer) ReconcileNamespace(obj *v1.Namespace) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileNamespace", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockNamespaceFinalizerMockRecorder) ReconcileNamespace(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileNamespace", reflect.TypeOf((*MockNamespaceFinalizer)(nil).ReconcileNamespace), obj)
}