func (m *MockNamespaceEventHandler) UpdateNamespace(old, new *v1.Namespace) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNamespace", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}
UpdateNamespace 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"
	v1 "k8s.io/api/core/v1"
	predicate "sigs.k8s.io/controller-runtime/pkg/predicate"
)
type MockSecretEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockSecretEventHandlerMockRecorder
}
type MockSecretEventHandlerMockRecorder struct {
	mock *MockSecretEventHandler
}
func NewMockSecretEventHandler(ctrl *gomock.Controller) *MockSecretEventHandler {
	mock := &MockSecretEventHandler{ctrl: ctrl}
	mock.recorder = &MockSecretEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockSecretEventHandler) EXPECT() *MockSecretEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockSecretEventHandler) CreateSecret(obj *v1.Secret) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecret", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretEventHandlerMockRecorder) CreateSecret(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockSecretEventHandler)(nil).CreateSecret), obj)
}
func (m *MockSecretEventHandler) UpdateSecret(old, new *v1.Secret) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecret", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretEventHandlerMockRecorder) UpdateSecret(old, new interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecret", reflect.TypeOf((*MockSecretEventHandler)(nil).UpdateSecret), old, new)
}
func (m *MockSecretEventHandler) DeleteSecret(obj *v1.Secret) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecret", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretEventHandlerMockRecorder) DeleteSecret(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockSecretEventHandler)(nil).DeleteSecret), obj)
}
func (m *MockSecretEventHandler) GenericSecret(obj *v1.Secret) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenericSecret", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretEventHandlerMockRecorder) GenericSecret(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenericSecret", reflect.TypeOf((*MockSecretEventHandler)(nil).GenericSecret), obj)
}
type MockSecretEventWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockSecretEventWatcherMockRecorder
}
type MockSecretEventWatcherMockRecorder struct {
	mock *MockSecretEventWatcher
}
func NewMockSecretEventWatcher(ctrl *gomock.Controller) *MockSecretEventWatcher {
	mock := &MockSecretEventWatcher{ctrl: ctrl}
	mock.recorder = &MockSecretEventWatcherMockRecorder{mock}
	return mock
}
func (m *MockSecretEventWatcher) EXPECT() *MockSecretEventWatcherMockRecorder {
	return m.recorder
}
func (m *MockSecretEventWatcher) AddEventHandler(ctx context.Context, h controller.SecretEventHandler, predicates ...predicate.Predicate) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, h}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddEventHandler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretEventWatcherMockRecorder) AddEventHandler(ctx, h interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, h}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventHandler", reflect.TypeOf((*MockSecretEventWatcher)(nil).AddEventHandler), varargs...)
}
type MockServiceAccountEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountEventHandlerMockRecorder
}
type MockServiceAccountEventHandlerMockRecorder struct {
	mock *MockServiceAccountEventHandler
}
func NewMockServiceAccountEventHandler(ctrl *gomock.Controller) *MockServiceAccountEventHandler {
	mock := &MockServiceAccountEventHandler{ctrl: ctrl}
	mock.recorder = &MockServiceAccountEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountEventHandler) EXPECT() *MockServiceAccountEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountEventHandler) CreateServiceAccount(obj *v1.ServiceAccount) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServiceAccount", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountEventHandlerMockRecorder) CreateServiceAccount(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceAccount", reflect.TypeOf((*MockServiceAccountEventHandler)(nil).CreateServiceAccount), obj)
}
func (m *MockServiceAccountEventHandler) UpdateServiceAccount(old, new *v1.ServiceAccount) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceAccount", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountEventHandlerMockRecorder) UpdateServiceAccount(old, new interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceAccount", reflect.TypeOf((*MockServiceAccountEventHandler)(nil).UpdateServiceAccount), old, new)
}
func (m *MockServiceAccountEventHandler) DeleteServiceAccount(obj *v1.ServiceAccount) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServiceAccount", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountEventHandlerMockRecorder) DeleteServiceAccount(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceAccount", reflect.TypeOf((*MockServiceAccountEventHandler)(nil).DeleteServiceAccount), obj)
}
func (m *MockServiceAccountEventHandler) GenericServiceAccount(obj *v1.ServiceAccount) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenericServiceAccount", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountEventHandlerMockRecorder) GenericServiceAccount(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenericServiceAccount", reflect.TypeOf((*MockServiceAccountEventHandler)(nil).GenericServiceAccount), obj)
}
type MockServiceAccountEventWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountEventWatcherMockRecorder
}
type MockServiceAccountEventWatcherMockRecorder struct {
	mock *MockServiceAccountEventWatcher
}
func NewMockServiceAccountEventWatcher(ctrl *gomock.Controller) *MockServiceAccountEventWatcher {
	mock := &MockServiceAccountEventWatcher{ctrl: ctrl}
	mock.recorder = &MockServiceAccountEventWatcherMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountEventWatcher) EXPECT() *MockServiceAccountEventWatcherMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountEventWatcher) AddEventHandler(ctx context.Context, h controller.ServiceAccountEventHandler, predicates ...predicate.Predicate) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, h}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddEventHandler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountEventWatcherMockRecorder) AddEventHandler(ctx, h interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, h}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventHandler", reflect.TypeOf((*MockServiceAccountEventWatcher)(nil).AddEventHandler), varargs...)
}
type MockNamespaceEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceEventHandlerMockRecorder
}
type MockNamespaceEventHandlerMockRecorder struct {
	mock *MockNamespaceEventHandler
}
func NewMockNamespaceEventHandler(ctrl *gomock.Controller) *MockNamespaceEventHandler {
	mock := &MockNamespaceEventHandler{ctrl: ctrl}
	mock.recorder = &MockNamespaceEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockNamespaceEventHandler) EXPECT() *MockNamespaceEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockNamespaceEventHandler) CreateNamespace(obj *v1.Namespace) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockNamespaceEventHandlerMockRecorder) CreateNamespace(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockNamespaceEventHandler)(nil).CreateNamespace), obj)
}