// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/rancher/rancher/pkg/generated/norman/rbac.authorization.k8s.io/v1 (interfaces: ClusterRoleBindingInterface,ClusterRoleBindingLister)
//
// Generated by this command:
//
//	mockgen -package=rbac -destination=v1rbacMocks_test.go github.com/rancher/rancher/pkg/generated/norman/rbac.authorization.k8s.io/v1 ClusterRoleBindingInterface,ClusterRoleBindingLister
//

// Package rbac is a generated GoMock package.
package rbac

import (
	context "context"
	reflect "reflect"

	objectclient "github.com/rancher/norman/objectclient"
	v1 "github.com/rancher/rancher/pkg/generated/norman/rbac.authorization.k8s.io/v1"
	gomock "go.uber.org/mock/gomock"
	v10 "k8s.io/api/rbac/v1"
	v11 "k8s.io/apimachinery/pkg/apis/meta/v1"
	labels "k8s.io/apimachinery/pkg/labels"
	watch "k8s.io/apimachinery/pkg/watch"
)

// MockClusterRoleBindingInterface is a mock of ClusterRoleBindingInterface interface.
type MockClusterRoleBindingInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingInterfaceMockRecorder
	isgomock struct{}
}

// MockClusterRoleBindingInterfaceMockRecorder is the mock recorder for MockClusterRoleBindingInterface.
type MockClusterRoleBindingInterfaceMockRecorder struct {
	mock *MockClusterRoleBindingInterface
}

// NewMockClusterRoleBindingInterface creates a new mock instance.
func NewMockClusterRoleBindingInterface(ctrl *gomock.Controller) *MockClusterRoleBindingInterface {
	mock := &MockClusterRoleBindingInterface{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterRoleBindingInterface) EXPECT() *MockClusterRoleBindingInterfaceMockRecorder {
	return m.recorder
}

// AddClusterScopedFeatureHandler mocks base method.
func (m *MockClusterRoleBindingInterface) AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync v1.ClusterRoleBindingHandlerFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddClusterScopedFeatureHandler", ctx, enabled, name, clusterName, sync)
}

// AddClusterScopedFeatureHandler indicates an expected call of AddClusterScopedFeatureHandler.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddClusterScopedFeatureHandler(ctx, enabled, name, clusterName, sync any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClusterScopedFeatureHandler", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddClusterScopedFeatureHandler), ctx, enabled, name, clusterName, sync)
}

// AddClusterScopedFeatureLifecycle mocks base method.
func (m *MockClusterRoleBindingInterface) AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle v1.ClusterRoleBindingLifecycle) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddClusterScopedFeatureLifecycle", ctx, enabled, name, clusterName, lifecycle)
}

// AddClusterScopedFeatureLifecycle indicates an expected call of AddClusterScopedFeatureLifecycle.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddClusterScopedFeatureLifecycle(ctx, enabled, name, clusterName, lifecycle any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClusterScopedFeatureLifecycle", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddClusterScopedFeatureLifecycle), ctx, enabled, name, clusterName, lifecycle)
}

// AddClusterScopedHandler mocks base method.
func (m *MockClusterRoleBindingInterface) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync v1.ClusterRoleBindingHandlerFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddClusterScopedHandler", ctx, name, clusterName, sync)
}

// AddClusterScopedHandler indicates an expected call of AddClusterScopedHandler.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddClusterScopedHandler(ctx, name, clusterName, sync any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClusterScopedHandler", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddClusterScopedHandler), ctx, name, clusterName, sync)
}

// AddClusterScopedLifecycle mocks base method.
func (m *MockClusterRoleBindingInterface) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle v1.ClusterRoleBindingLifecycle) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddClusterScopedLifecycle", ctx, name, clusterName, lifecycle)
}

// AddClusterScopedLifecycle indicates an expected call of AddClusterScopedLifecycle.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddClusterScopedLifecycle(ctx, name, clusterName, lifecycle any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClusterScopedLifecycle", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddClusterScopedLifecycle), ctx, name, clusterName, lifecycle)
}

// AddFeatureHandler mocks base method.
func (m *MockClusterRoleBindingInterface) AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync v1.ClusterRoleBindingHandlerFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddFeatureHandler", ctx, enabled, name, sync)
}

// AddFeatureHandler indicates an expected call of AddFeatureHandler.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddFeatureHandler(ctx, enabled, name, sync any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFeatureHandler", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddFeatureHandler), ctx, enabled, name, sync)
}

// AddFeatureLifecycle mocks base method.
func (m *MockClusterRoleBindingInterface) AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle v1.ClusterRoleBindingLifecycle) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddFeatureLifecycle", ctx, enabled, name, lifecycle)
}

// AddFeatureLifecycle indicates an expected call of AddFeatureLifecycle.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddFeatureLifecycle(ctx, enabled, name, lifecycle any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFeatureLifecycle", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddFeatureLifecycle), ctx, enabled, name, lifecycle)
}

// AddHandler mocks base method.
func (m *MockClusterRoleBindingInterface) AddHandler(ctx context.Context, name string, sync v1.ClusterRoleBindingHandlerFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHandler", ctx, name, sync)
}

// AddHandler indicates an expected call of AddHandler.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddHandler(ctx, name, sync any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHandler", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddHandler), ctx, name, sync)
}

// AddLifecycle mocks base method.
func (m *MockClusterRoleBindingInterface) AddLifecycle(ctx context.Context, name string, lifecycle v1.ClusterRoleBindingLifecycle) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddLifecycle", ctx, name, lifecycle)
}

// AddLifecycle indicates an expected call of AddLifecycle.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) AddLifecycle(ctx, name, lifecycle any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLifecycle", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).AddLifecycle), ctx, name, lifecycle)
}

// Controller mocks base method.
func (m *MockClusterRoleBindingInterface) Controller() v1.ClusterRoleBindingController {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Controller")
	ret0, _ := ret[0].(v1.ClusterRoleBindingController)
	return ret0
}

// Controller indicates an expected call of Controller.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) Controller() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Controller", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).Controller))
}

// Create mocks base method.
func (m *MockClusterRoleBindingInterface) Create(arg0 *v10.ClusterRoleBinding) (*v10.ClusterRoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0)
	ret0, _ := ret[0].(*v10.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) Create(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).Create), arg0)
}

// Delete mocks base method.
func (m *MockClusterRoleBindingInterface) Delete(name string, options *v11.DeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) Delete(name, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).Delete), name, options)
}

// DeleteCollection mocks base method.
func (m *MockClusterRoleBindingInterface) DeleteCollection(deleteOpts *v11.DeleteOptions, listOpts v11.ListOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCollection", deleteOpts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCollection indicates an expected call of DeleteCollection.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) DeleteCollection(deleteOpts, listOpts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCollection", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).DeleteCollection), deleteOpts, listOpts)
}

// DeleteNamespaced mocks base method.
func (m *MockClusterRoleBindingInterface) DeleteNamespaced(namespace, name string, options *v11.DeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespaced", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNamespaced indicates an expected call of DeleteNamespaced.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) DeleteNamespaced(namespace, name, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespaced", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).DeleteNamespaced), namespace, name, options)
}

// Get mocks base method.
func (m *MockClusterRoleBindingInterface) Get(name string, opts v11.GetOptions) (*v10.ClusterRoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", name, opts)
	ret0, _ := ret[0].(*v10.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) Get(name, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).Get), name, opts)
}

// GetNamespaced mocks base method.
func (m *MockClusterRoleBindingInterface) GetNamespaced(namespace, name string, opts v11.GetOptions) (*v10.ClusterRoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaced", namespace, name, opts)
	ret0, _ := ret[0].(*v10.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespaced indicates an expected call of GetNamespaced.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) GetNamespaced(namespace, name, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaced", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).GetNamespaced), namespace, name, opts)
}

// List mocks base method.
func (m *MockClusterRoleBindingInterface) List(opts v11.ListOptions) (*v10.ClusterRoleBindingList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", opts)
	ret0, _ := ret[0].(*v10.ClusterRoleBindingList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) List(opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).List), opts)
}

// ListNamespaced mocks base method.
func (m *MockClusterRoleBindingInterface) ListNamespaced(namespace string, opts v11.ListOptions) (*v10.ClusterRoleBindingList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespaced", namespace, opts)
	ret0, _ := ret[0].(*v10.ClusterRoleBindingList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNamespaced indicates an expected call of ListNamespaced.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) ListNamespaced(namespace, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaced", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).ListNamespaced), namespace, opts)
}

// ObjectClient mocks base method.
func (m *MockClusterRoleBindingInterface) ObjectClient() *objectclient.ObjectClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectClient")
	ret0, _ := ret[0].(*objectclient.ObjectClient)
	return ret0
}

// ObjectClient indicates an expected call of ObjectClient.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) ObjectClient() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectClient", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).ObjectClient))
}

// Update mocks base method.
func (m *MockClusterRoleBindingInterface) Update(arg0 *v10.ClusterRoleBinding) (*v10.ClusterRoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0)
	ret0, _ := ret[0].(*v10.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) Update(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).Update), arg0)
}

// Watch mocks base method.
func (m *MockClusterRoleBindingInterface) Watch(opts v11.ListOptions) (watch.Interface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Watch", opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockClusterRoleBindingInterfaceMockRecorder) Watch(opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockClusterRoleBindingInterface)(nil).Watch), opts)
}

// MockClusterRoleBindingLister is a mock of ClusterRoleBindingLister interface.
type MockClusterRoleBindingLister struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingListerMockRecorder
	isgomock struct{}
}

// MockClusterRoleBindingListerMockRecorder is the mock recorder for MockClusterRoleBindingLister.
type MockClusterRoleBindingListerMockRecorder struct {
	mock *MockClusterRoleBindingLister
}

// NewMockClusterRoleBindingLister creates a new mock instance.
func NewMockClusterRoleBindingLister(ctrl *gomock.Controller) *MockClusterRoleBindingLister {
	mock := &MockClusterRoleBindingLister{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingListerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterRoleBindingLister) EXPECT() *MockClusterRoleBindingListerMockRecorder {
	return m.recorder
}

// Get mocks base method.
func (m *MockClusterRoleBindingLister) Get(namespace, name string) (*v10.ClusterRoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", namespace, name)
	ret0, _ := ret[0].(*v10.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockClusterRoleBindingListerMockRecorder) Get(namespace, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClusterRoleBindingLister)(nil).Get), namespace, name)
}

// List mocks base method.
func (m *MockClusterRoleBindingLister) List(namespace string, selector labels.Selector) ([]*v10.ClusterRoleBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", namespace, selector)
	ret0, _ := ret[0].([]*v10.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockClusterRoleBindingListerMockRecorder) List(namespace, selector any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClusterRoleBindingLister)(nil).List), namespace, selector)
}
