// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/rancher/rancher/pkg/generated/norman/management.cattle.io/v3 (interfaces: ClusterInterface)
//
// Generated by this command:
//
//	mockgen -package=rbac -destination=v3mgmntMocks_test.go github.com/rancher/rancher/pkg/generated/norman/management.cattle.io/v3 ClusterInterface
//

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

import (
	context "context"
	reflect "reflect"

	objectclient "github.com/rancher/norman/objectclient"
	v3 "github.com/rancher/rancher/pkg/apis/management.cattle.io/v3"
	v30 "github.com/rancher/rancher/pkg/generated/norman/management.cattle.io/v3"
	gomock "go.uber.org/mock/gomock"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	watch "k8s.io/apimachinery/pkg/watch"
)

// MockClusterInterface is a mock of ClusterInterface interface.
type MockClusterInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClusterInterfaceMockRecorder
	isgomock struct{}
}

// MockClusterInterfaceMockRecorder is the mock recorder for MockClusterInterface.
type MockClusterInterfaceMockRecorder struct {
	mock *MockClusterInterface
}

// NewMockClusterInterface creates a new mock instance.
func NewMockClusterInterface(ctrl *gomock.Controller) *MockClusterInterface {
	mock := &MockClusterInterface{ctrl: ctrl}
	mock.recorder = &MockClusterInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Delete mocks base method.
func (m *MockClusterInterface) Delete(name string, options *v1.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 *MockClusterInterfaceMockRecorder) Delete(name, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClusterInterface)(nil).Delete), name, options)
}

// DeleteCollection mocks base method.
func (m *MockClusterInterface) DeleteCollection(deleteOpts *v1.DeleteOptions, listOpts v1.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 *MockClusterInterfaceMockRecorder) DeleteCollection(deleteOpts, listOpts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCollection", reflect.TypeOf((*MockClusterInterface)(nil).DeleteCollection), deleteOpts, listOpts)
}

// DeleteNamespaced mocks base method.
func (m *MockClusterInterface) DeleteNamespaced(namespace, name string, options *v1.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 *MockClusterInterfaceMockRecorder) DeleteNamespaced(namespace, name, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespaced", reflect.TypeOf((*MockClusterInterface)(nil).DeleteNamespaced), namespace, name, options)
}

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

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

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

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

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

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

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

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

// ObjectClient mocks base method.
func (m *MockClusterInterface) 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 *MockClusterInterfaceMockRecorder) ObjectClient() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectClient", reflect.TypeOf((*MockClusterInterface)(nil).ObjectClient))
}

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

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

// Watch mocks base method.
func (m *MockClusterInterface) Watch(opts v1.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 *MockClusterInterfaceMockRecorder) Watch(opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockClusterInterface)(nil).Watch), opts)
}
