func (mr *MockClusterRoleBindingEventHandlerMockRecorder) UpdateClusterRoleBinding(old, new interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingEventHandler)(nil).UpdateClusterRoleBinding), old, new)
}
UpdateClusterRoleBinding indicates an expected call of UpdateClusterRoleBinding
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"
	v1 "k8s.io/api/rbac/v1"
	predicate "sigs.k8s.io/controller-runtime/pkg/predicate"
)
type MockRoleEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleEventHandlerMockRecorder
}
type MockRoleEventHandlerMockRecorder struct {
	mock *MockRoleEventHandler
}
func NewMockRoleEventHandler(ctrl *gomock.Controller) *MockRoleEventHandler {
	mock := &MockRoleEventHandler{ctrl: ctrl}
	mock.recorder = &MockRoleEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockRoleEventHandler) EXPECT() *MockRoleEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockRoleEventHandler) CreateRole(obj *v1.Role) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleEventHandlerMockRecorder) CreateRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockRoleEventHandler)(nil).CreateRole), obj)
}
func (m *MockRoleEventHandler) UpdateRole(old, new *v1.Role) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRole", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleEventHandlerMockRecorder) UpdateRole(old, new interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRole", reflect.TypeOf((*MockRoleEventHandler)(nil).UpdateRole), old, new)
}
func (m *MockRoleEventHandler) DeleteRole(obj *v1.Role) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleEventHandlerMockRecorder) DeleteRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockRoleEventHandler)(nil).DeleteRole), obj)
}
func (m *MockRoleEventHandler) GenericRole(obj *v1.Role) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenericRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleEventHandlerMockRecorder) GenericRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenericRole", reflect.TypeOf((*MockRoleEventHandler)(nil).GenericRole), obj)
}
type MockRoleEventWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockRoleEventWatcherMockRecorder
}
type MockRoleEventWatcherMockRecorder struct {
	mock *MockRoleEventWatcher
}
func NewMockRoleEventWatcher(ctrl *gomock.Controller) *MockRoleEventWatcher {
	mock := &MockRoleEventWatcher{ctrl: ctrl}
	mock.recorder = &MockRoleEventWatcherMockRecorder{mock}
	return mock
}
func (m *MockRoleEventWatcher) EXPECT() *MockRoleEventWatcherMockRecorder {
	return m.recorder
}
func (m *MockRoleEventWatcher) AddEventHandler(ctx context.Context, h controller.RoleEventHandler, 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 *MockRoleEventWatcherMockRecorder) 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((*MockRoleEventWatcher)(nil).AddEventHandler), varargs...)
}
type MockRoleBindingEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingEventHandlerMockRecorder
}
type MockRoleBindingEventHandlerMockRecorder struct {
	mock *MockRoleBindingEventHandler
}
func NewMockRoleBindingEventHandler(ctrl *gomock.Controller) *MockRoleBindingEventHandler {
	mock := &MockRoleBindingEventHandler{ctrl: ctrl}
	mock.recorder = &MockRoleBindingEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingEventHandler) EXPECT() *MockRoleBindingEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingEventHandler) CreateRoleBinding(obj *v1.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingEventHandlerMockRecorder) CreateRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoleBinding", reflect.TypeOf((*MockRoleBindingEventHandler)(nil).CreateRoleBinding), obj)
}
func (m *MockRoleBindingEventHandler) UpdateRoleBinding(old, new *v1.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRoleBinding", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingEventHandlerMockRecorder) UpdateRoleBinding(old, new interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleBinding", reflect.TypeOf((*MockRoleBindingEventHandler)(nil).UpdateRoleBinding), old, new)
}
func (m *MockRoleBindingEventHandler) DeleteRoleBinding(obj *v1.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingEventHandlerMockRecorder) DeleteRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleBinding", reflect.TypeOf((*MockRoleBindingEventHandler)(nil).DeleteRoleBinding), obj)
}
func (m *MockRoleBindingEventHandler) GenericRoleBinding(obj *v1.RoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenericRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingEventHandlerMockRecorder) GenericRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenericRoleBinding", reflect.TypeOf((*MockRoleBindingEventHandler)(nil).GenericRoleBinding), obj)
}
type MockRoleBindingEventWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingEventWatcherMockRecorder
}
type MockRoleBindingEventWatcherMockRecorder struct {
	mock *MockRoleBindingEventWatcher
}
func NewMockRoleBindingEventWatcher(ctrl *gomock.Controller) *MockRoleBindingEventWatcher {
	mock := &MockRoleBindingEventWatcher{ctrl: ctrl}
	mock.recorder = &MockRoleBindingEventWatcherMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingEventWatcher) EXPECT() *MockRoleBindingEventWatcherMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingEventWatcher) AddEventHandler(ctx context.Context, h controller.RoleBindingEventHandler, 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 *MockRoleBindingEventWatcherMockRecorder) 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((*MockRoleBindingEventWatcher)(nil).AddEventHandler), varargs...)
}
type MockClusterRoleEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleEventHandlerMockRecorder
}
type MockClusterRoleEventHandlerMockRecorder struct {
	mock *MockClusterRoleEventHandler
}
func NewMockClusterRoleEventHandler(ctrl *gomock.Controller) *MockClusterRoleEventHandler {
	mock := &MockClusterRoleEventHandler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockClusterRoleEventHandler) EXPECT() *MockClusterRoleEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockClusterRoleEventHandler) CreateClusterRole(obj *v1.ClusterRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClusterRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterRoleEventHandlerMockRecorder) CreateClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterRole", reflect.TypeOf((*MockClusterRoleEventHandler)(nil).CreateClusterRole), obj)
}
func (m *MockClusterRoleEventHandler) UpdateClusterRole(old, new *v1.ClusterRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterRole", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterRoleEventHandlerMockRecorder) UpdateClusterRole(old, new interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterRole", reflect.TypeOf((*MockClusterRoleEventHandler)(nil).UpdateClusterRole), old, new)
}
func (m *MockClusterRoleEventHandler) DeleteClusterRole(obj *v1.ClusterRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClusterRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterRoleEventHandlerMockRecorder) DeleteClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterRole", reflect.TypeOf((*MockClusterRoleEventHandler)(nil).DeleteClusterRole), obj)
}
func (m *MockClusterRoleEventHandler) GenericClusterRole(obj *v1.ClusterRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenericClusterRole", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterRoleEventHandlerMockRecorder) GenericClusterRole(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenericClusterRole", reflect.TypeOf((*MockClusterRoleEventHandler)(nil).GenericClusterRole), obj)
}
type MockClusterRoleEventWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleEventWatcherMockRecorder
}
type MockClusterRoleEventWatcherMockRecorder struct {
	mock *MockClusterRoleEventWatcher
}
func NewMockClusterRoleEventWatcher(ctrl *gomock.Controller) *MockClusterRoleEventWatcher {
	mock := &MockClusterRoleEventWatcher{ctrl: ctrl}
	mock.recorder = &MockClusterRoleEventWatcherMockRecorder{mock}
	return mock
}
func (m *MockClusterRoleEventWatcher) EXPECT() *MockClusterRoleEventWatcherMockRecorder {
	return m.recorder
}
func (m *MockClusterRoleEventWatcher) AddEventHandler(ctx context.Context, h controller.ClusterRoleEventHandler, 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 *MockClusterRoleEventWatcherMockRecorder) 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((*MockClusterRoleEventWatcher)(nil).AddEventHandler), varargs...)
}
type MockClusterRoleBindingEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingEventHandlerMockRecorder
}
type MockClusterRoleBindingEventHandlerMockRecorder struct {
	mock *MockClusterRoleBindingEventHandler
}
func NewMockClusterRoleBindingEventHandler(ctrl *gomock.Controller) *MockClusterRoleBindingEventHandler {
	mock := &MockClusterRoleBindingEventHandler{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingEventHandlerMockRecorder{mock}
	return mock
}
func (m *MockClusterRoleBindingEventHandler) EXPECT() *MockClusterRoleBindingEventHandlerMockRecorder {
	return m.recorder
}
func (m *MockClusterRoleBindingEventHandler) CreateClusterRoleBinding(obj *v1.ClusterRoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClusterRoleBinding", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterRoleBindingEventHandlerMockRecorder) CreateClusterRoleBinding(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingEventHandler)(nil).CreateClusterRoleBinding), obj)
}
func (m *MockClusterRoleBindingEventHandler) UpdateClusterRoleBinding(old, new *v1.ClusterRoleBinding) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterRoleBinding", old, new)
	ret0, _ := ret[0].(error)
	return ret0
}