func (m *MockRoleBindingClient) ListRoleBinding(ctx context.Context, opts ...client.ListOption) (*v10.RoleBindingList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRoleBinding", varargs...)
	ret0, _ := ret[0].(*v10.RoleBindingList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
ListRoleBinding mocks base method
package mock_v1
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	v1 "github.com/solo-io/skv2/pkg/multicluster/internal/k8s/rbac.authorization.k8s.io/v1"
	v10 "k8s.io/api/rbac/v1"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)
type MockMulticlusterClientset struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterClientsetMockRecorder
}
type MockMulticlusterClientsetMockRecorder struct {
	mock *MockMulticlusterClientset
}
func NewMockMulticlusterClientset(ctrl *gomock.Controller) *MockMulticlusterClientset {
	mock := &MockMulticlusterClientset{ctrl: ctrl}
	mock.recorder = &MockMulticlusterClientsetMockRecorder{mock}
	return mock
}
func (m *MockMulticlusterClientset) EXPECT() *MockMulticlusterClientsetMockRecorder {
	return m.recorder
}
func (m *MockMulticlusterClientset) Cluster(cluster string) (v1.Clientset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cluster", cluster)
	ret0, _ := ret[0].(v1.Clientset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMulticlusterClientsetMockRecorder) Cluster(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cluster", reflect.TypeOf((*MockMulticlusterClientset)(nil).Cluster), cluster)
}
type MockClientset struct {
	ctrl     *gomock.Controller
	recorder *MockClientsetMockRecorder
}
type MockClientsetMockRecorder struct {
	mock *MockClientset
}
func NewMockClientset(ctrl *gomock.Controller) *MockClientset {
	mock := &MockClientset{ctrl: ctrl}
	mock.recorder = &MockClientsetMockRecorder{mock}
	return mock
}
func (m *MockClientset) EXPECT() *MockClientsetMockRecorder {
	return m.recorder
}
func (m *MockClientset) Roles() v1.RoleClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Roles")
	ret0, _ := ret[0].(v1.RoleClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) Roles() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Roles", reflect.TypeOf((*MockClientset)(nil).Roles))
}
func (m *MockClientset) RoleBindings() v1.RoleBindingClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoleBindings")
	ret0, _ := ret[0].(v1.RoleBindingClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) RoleBindings() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleBindings", reflect.TypeOf((*MockClientset)(nil).RoleBindings))
}
func (m *MockClientset) ClusterRoles() v1.ClusterRoleClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterRoles")
	ret0, _ := ret[0].(v1.ClusterRoleClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) ClusterRoles() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterRoles", reflect.TypeOf((*MockClientset)(nil).ClusterRoles))
}
func (m *MockClientset) ClusterRoleBindings() v1.ClusterRoleBindingClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterRoleBindings")
	ret0, _ := ret[0].(v1.ClusterRoleBindingClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) ClusterRoleBindings() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterRoleBindings", reflect.TypeOf((*MockClientset)(nil).ClusterRoleBindings))
}
type MockRoleReader struct {
	ctrl     *gomock.Controller
	recorder *MockRoleReaderMockRecorder
}
type MockRoleReaderMockRecorder struct {
	mock *MockRoleReader
}
func NewMockRoleReader(ctrl *gomock.Controller) *MockRoleReader {
	mock := &MockRoleReader{ctrl: ctrl}
	mock.recorder = &MockRoleReaderMockRecorder{mock}
	return mock
}
func (m *MockRoleReader) EXPECT() *MockRoleReaderMockRecorder {
	return m.recorder
}
func (m *MockRoleReader) GetRole(ctx context.Context, key client.ObjectKey) (*v10.Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRole", ctx, key)
	ret0, _ := ret[0].(*v10.Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleReaderMockRecorder) GetRole(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockRoleReader)(nil).GetRole), ctx, key)
}
func (m *MockRoleReader) ListRole(ctx context.Context, opts ...client.ListOption) (*v10.RoleList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRole", varargs...)
	ret0, _ := ret[0].(*v10.RoleList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleReaderMockRecorder) ListRole(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRole", reflect.TypeOf((*MockRoleReader)(nil).ListRole), varargs...)
}
type MockRoleWriter struct {
	ctrl     *gomock.Controller
	recorder *MockRoleWriterMockRecorder
}
type MockRoleWriterMockRecorder struct {
	mock *MockRoleWriter
}
func NewMockRoleWriter(ctrl *gomock.Controller) *MockRoleWriter {
	mock := &MockRoleWriter{ctrl: ctrl}
	mock.recorder = &MockRoleWriterMockRecorder{mock}
	return mock
}
func (m *MockRoleWriter) EXPECT() *MockRoleWriterMockRecorder {
	return m.recorder
}
func (m *MockRoleWriter) CreateRole(ctx context.Context, obj *v10.Role, opts ...client.CreateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleWriterMockRecorder) CreateRole(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockRoleWriter)(nil).CreateRole), varargs...)
}
func (m *MockRoleWriter) DeleteRole(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleWriterMockRecorder) DeleteRole(ctx, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockRoleWriter)(nil).DeleteRole), varargs...)
}
func (m *MockRoleWriter) UpdateRole(ctx context.Context, obj *v10.Role, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleWriterMockRecorder) UpdateRole(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRole", reflect.TypeOf((*MockRoleWriter)(nil).UpdateRole), varargs...)
}
func (m *MockRoleWriter) PatchRole(ctx context.Context, obj *v10.Role, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleWriterMockRecorder) PatchRole(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRole", reflect.TypeOf((*MockRoleWriter)(nil).PatchRole), varargs...)
}
func (m *MockRoleWriter) DeleteAllOfRole(ctx context.Context, opts ...client.DeleteAllOfOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAllOfRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleWriterMockRecorder) DeleteAllOfRole(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfRole", reflect.TypeOf((*MockRoleWriter)(nil).DeleteAllOfRole), varargs...)
}
func (m *MockRoleWriter) UpsertRole(ctx context.Context, obj *v10.Role, transitionFuncs ...v1.RoleTransitionFunction) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range transitionFuncs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleWriterMockRecorder) UpsertRole(ctx, obj interface{}, transitionFuncs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, transitionFuncs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRole", reflect.TypeOf((*MockRoleWriter)(nil).UpsertRole), varargs...)
}
type MockRoleStatusWriter struct {
	ctrl     *gomock.Controller
	recorder *MockRoleStatusWriterMockRecorder
}
type MockRoleStatusWriterMockRecorder struct {
	mock *MockRoleStatusWriter
}
func NewMockRoleStatusWriter(ctrl *gomock.Controller) *MockRoleStatusWriter {
	mock := &MockRoleStatusWriter{ctrl: ctrl}
	mock.recorder = &MockRoleStatusWriterMockRecorder{mock}
	return mock
}
func (m *MockRoleStatusWriter) EXPECT() *MockRoleStatusWriterMockRecorder {
	return m.recorder
}
func (m *MockRoleStatusWriter) UpdateRoleStatus(ctx context.Context, obj *v10.Role, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRoleStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleStatusWriterMockRecorder) UpdateRoleStatus(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleStatus", reflect.TypeOf((*MockRoleStatusWriter)(nil).UpdateRoleStatus), varargs...)
}
func (m *MockRoleStatusWriter) PatchRoleStatus(ctx context.Context, obj *v10.Role, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchRoleStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleStatusWriterMockRecorder) PatchRoleStatus(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRoleStatus", reflect.TypeOf((*MockRoleStatusWriter)(nil).PatchRoleStatus), varargs...)
}
type MockRoleClient struct {
	ctrl     *gomock.Controller
	recorder *MockRoleClientMockRecorder
}
type MockRoleClientMockRecorder struct {
	mock *MockRoleClient
}
func NewMockRoleClient(ctrl *gomock.Controller) *MockRoleClient {
	mock := &MockRoleClient{ctrl: ctrl}
	mock.recorder = &MockRoleClientMockRecorder{mock}
	return mock
}
func (m *MockRoleClient) EXPECT() *MockRoleClientMockRecorder {
	return m.recorder
}
func (m *MockRoleClient) GetRole(ctx context.Context, key client.ObjectKey) (*v10.Role, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRole", ctx, key)
	ret0, _ := ret[0].(*v10.Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleClientMockRecorder) GetRole(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockRoleClient)(nil).GetRole), ctx, key)
}
func (m *MockRoleClient) ListRole(ctx context.Context, opts ...client.ListOption) (*v10.RoleList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRole", varargs...)
	ret0, _ := ret[0].(*v10.RoleList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleClientMockRecorder) ListRole(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRole", reflect.TypeOf((*MockRoleClient)(nil).ListRole), varargs...)
}
func (m *MockRoleClient) CreateRole(ctx context.Context, obj *v10.Role, opts ...client.CreateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) CreateRole(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockRoleClient)(nil).CreateRole), varargs...)
}
func (m *MockRoleClient) DeleteRole(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) DeleteRole(ctx, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockRoleClient)(nil).DeleteRole), varargs...)
}
func (m *MockRoleClient) UpdateRole(ctx context.Context, obj *v10.Role, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) UpdateRole(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRole", reflect.TypeOf((*MockRoleClient)(nil).UpdateRole), varargs...)
}
func (m *MockRoleClient) PatchRole(ctx context.Context, obj *v10.Role, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) PatchRole(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRole", reflect.TypeOf((*MockRoleClient)(nil).PatchRole), varargs...)
}
func (m *MockRoleClient) DeleteAllOfRole(ctx context.Context, opts ...client.DeleteAllOfOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAllOfRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) DeleteAllOfRole(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfRole", reflect.TypeOf((*MockRoleClient)(nil).DeleteAllOfRole), varargs...)
}
func (m *MockRoleClient) UpsertRole(ctx context.Context, obj *v10.Role, transitionFuncs ...v1.RoleTransitionFunction) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range transitionFuncs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertRole", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) UpsertRole(ctx, obj interface{}, transitionFuncs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, transitionFuncs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRole", reflect.TypeOf((*MockRoleClient)(nil).UpsertRole), varargs...)
}
func (m *MockRoleClient) UpdateRoleStatus(ctx context.Context, obj *v10.Role, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRoleStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) UpdateRoleStatus(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleStatus", reflect.TypeOf((*MockRoleClient)(nil).UpdateRoleStatus), varargs...)
}
func (m *MockRoleClient) PatchRoleStatus(ctx context.Context, obj *v10.Role, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchRoleStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleClientMockRecorder) PatchRoleStatus(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRoleStatus", reflect.TypeOf((*MockRoleClient)(nil).PatchRoleStatus), varargs...)
}
type MockMulticlusterRoleClient struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterRoleClientMockRecorder
}
type MockMulticlusterRoleClientMockRecorder struct {
	mock *MockMulticlusterRoleClient
}
func NewMockMulticlusterRoleClient(ctrl *gomock.Controller) *MockMulticlusterRoleClient {
	mock := &MockMulticlusterRoleClient{ctrl: ctrl}
	mock.recorder = &MockMulticlusterRoleClientMockRecorder{mock}
	return mock
}
func (m *MockMulticlusterRoleClient) EXPECT() *MockMulticlusterRoleClientMockRecorder {
	return m.recorder
}
func (m *MockMulticlusterRoleClient) Cluster(cluster string) (v1.RoleClient, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cluster", cluster)
	ret0, _ := ret[0].(v1.RoleClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMulticlusterRoleClientMockRecorder) Cluster(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cluster", reflect.TypeOf((*MockMulticlusterRoleClient)(nil).Cluster), cluster)
}
type MockRoleBindingReader struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingReaderMockRecorder
}
type MockRoleBindingReaderMockRecorder struct {
	mock *MockRoleBindingReader
}
func NewMockRoleBindingReader(ctrl *gomock.Controller) *MockRoleBindingReader {
	mock := &MockRoleBindingReader{ctrl: ctrl}
	mock.recorder = &MockRoleBindingReaderMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingReader) EXPECT() *MockRoleBindingReaderMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingReader) GetRoleBinding(ctx context.Context, key client.ObjectKey) (*v10.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoleBinding", ctx, key)
	ret0, _ := ret[0].(*v10.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleBindingReaderMockRecorder) GetRoleBinding(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleBinding", reflect.TypeOf((*MockRoleBindingReader)(nil).GetRoleBinding), ctx, key)
}
func (m *MockRoleBindingReader) ListRoleBinding(ctx context.Context, opts ...client.ListOption) (*v10.RoleBindingList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRoleBinding", varargs...)
	ret0, _ := ret[0].(*v10.RoleBindingList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleBindingReaderMockRecorder) ListRoleBinding(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoleBinding", reflect.TypeOf((*MockRoleBindingReader)(nil).ListRoleBinding), varargs...)
}
type MockRoleBindingWriter struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingWriterMockRecorder
}
type MockRoleBindingWriterMockRecorder struct {
	mock *MockRoleBindingWriter
}
func NewMockRoleBindingWriter(ctrl *gomock.Controller) *MockRoleBindingWriter {
	mock := &MockRoleBindingWriter{ctrl: ctrl}
	mock.recorder = &MockRoleBindingWriterMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingWriter) EXPECT() *MockRoleBindingWriterMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingWriter) CreateRoleBinding(ctx context.Context, obj *v10.RoleBinding, opts ...client.CreateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRoleBinding", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingWriterMockRecorder) CreateRoleBinding(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoleBinding", reflect.TypeOf((*MockRoleBindingWriter)(nil).CreateRoleBinding), varargs...)
}
func (m *MockRoleBindingWriter) DeleteRoleBinding(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRoleBinding", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingWriterMockRecorder) DeleteRoleBinding(ctx, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleBinding", reflect.TypeOf((*MockRoleBindingWriter)(nil).DeleteRoleBinding), varargs...)
}
func (m *MockRoleBindingWriter) UpdateRoleBinding(ctx context.Context, obj *v10.RoleBinding, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRoleBinding", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingWriterMockRecorder) UpdateRoleBinding(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleBinding", reflect.TypeOf((*MockRoleBindingWriter)(nil).UpdateRoleBinding), varargs...)
}
func (m *MockRoleBindingWriter) PatchRoleBinding(ctx context.Context, obj *v10.RoleBinding, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchRoleBinding", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingWriterMockRecorder) PatchRoleBinding(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRoleBinding", reflect.TypeOf((*MockRoleBindingWriter)(nil).PatchRoleBinding), varargs...)
}
func (m *MockRoleBindingWriter) DeleteAllOfRoleBinding(ctx context.Context, opts ...client.DeleteAllOfOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAllOfRoleBinding", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingWriterMockRecorder) DeleteAllOfRoleBinding(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfRoleBinding", reflect.TypeOf((*MockRoleBindingWriter)(nil).DeleteAllOfRoleBinding), varargs...)
}
func (m *MockRoleBindingWriter) UpsertRoleBinding(ctx context.Context, obj *v10.RoleBinding, transitionFuncs ...v1.RoleBindingTransitionFunction) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range transitionFuncs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertRoleBinding", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingWriterMockRecorder) UpsertRoleBinding(ctx, obj interface{}, transitionFuncs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, transitionFuncs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRoleBinding", reflect.TypeOf((*MockRoleBindingWriter)(nil).UpsertRoleBinding), varargs...)
}
type MockRoleBindingStatusWriter struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingStatusWriterMockRecorder
}
type MockRoleBindingStatusWriterMockRecorder struct {
	mock *MockRoleBindingStatusWriter
}
func NewMockRoleBindingStatusWriter(ctrl *gomock.Controller) *MockRoleBindingStatusWriter {
	mock := &MockRoleBindingStatusWriter{ctrl: ctrl}
	mock.recorder = &MockRoleBindingStatusWriterMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingStatusWriter) EXPECT() *MockRoleBindingStatusWriterMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingStatusWriter) UpdateRoleBindingStatus(ctx context.Context, obj *v10.RoleBinding, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRoleBindingStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingStatusWriterMockRecorder) UpdateRoleBindingStatus(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleBindingStatus", reflect.TypeOf((*MockRoleBindingStatusWriter)(nil).UpdateRoleBindingStatus), varargs...)
}
func (m *MockRoleBindingStatusWriter) PatchRoleBindingStatus(ctx context.Context, obj *v10.RoleBinding, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchRoleBindingStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockRoleBindingStatusWriterMockRecorder) PatchRoleBindingStatus(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRoleBindingStatus", reflect.TypeOf((*MockRoleBindingStatusWriter)(nil).PatchRoleBindingStatus), varargs...)
}
type MockRoleBindingClient struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingClientMockRecorder
}
type MockRoleBindingClientMockRecorder struct {
	mock *MockRoleBindingClient
}
func NewMockRoleBindingClient(ctrl *gomock.Controller) *MockRoleBindingClient {
	mock := &MockRoleBindingClient{ctrl: ctrl}
	mock.recorder = &MockRoleBindingClientMockRecorder{mock}
	return mock
}
func (m *MockRoleBindingClient) EXPECT() *MockRoleBindingClientMockRecorder {
	return m.recorder
}
func (m *MockRoleBindingClient) GetRoleBinding(ctx context.Context, key client.ObjectKey) (*v10.RoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoleBinding", ctx, key)
	ret0, _ := ret[0].(*v10.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockRoleBindingClientMockRecorder) GetRoleBinding(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleBinding", reflect.TypeOf((*MockRoleBindingClient)(nil).GetRoleBinding), ctx, key)
}