// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/rancher/lasso/pkg/controller (interfaces: SharedControllerFactory,SharedController)
//
// Generated by this command:
//
//	mockgen --build_flags=--mod=mod -package generic -destination ./controllerFactoryMocks_test.go github.com/rancher/lasso/pkg/controller SharedControllerFactory,SharedController
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	cache "github.com/rancher/lasso/pkg/cache"
	client "github.com/rancher/lasso/pkg/client"
	controller "github.com/rancher/lasso/pkg/controller"
	gomock "go.uber.org/mock/gomock"
	runtime "k8s.io/apimachinery/pkg/runtime"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	cache0 "k8s.io/client-go/tools/cache"
)

// MockSharedControllerFactory is a mock of SharedControllerFactory interface.
type MockSharedControllerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockSharedControllerFactoryMockRecorder
}

// MockSharedControllerFactoryMockRecorder is the mock recorder for MockSharedControllerFactory.
type MockSharedControllerFactoryMockRecorder struct {
	mock *MockSharedControllerFactory
}

// NewMockSharedControllerFactory creates a new mock instance.
func NewMockSharedControllerFactory(ctrl *gomock.Controller) *MockSharedControllerFactory {
	mock := &MockSharedControllerFactory{ctrl: ctrl}
	mock.recorder = &MockSharedControllerFactoryMockRecorder{mock}
	return mock
}

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

// ForKind mocks base method.
func (m *MockSharedControllerFactory) ForKind(arg0 schema.GroupVersionKind) (controller.SharedController, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForKind", arg0)
	ret0, _ := ret[0].(controller.SharedController)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForObject mocks base method.
func (m *MockSharedControllerFactory) ForObject(arg0 runtime.Object) (controller.SharedController, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForObject", arg0)
	ret0, _ := ret[0].(controller.SharedController)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForResource mocks base method.
func (m *MockSharedControllerFactory) ForResource(arg0 schema.GroupVersionResource, arg1 bool) controller.SharedController {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForResource", arg0, arg1)
	ret0, _ := ret[0].(controller.SharedController)
	return ret0
}

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

// ForResourceKind mocks base method.
func (m *MockSharedControllerFactory) ForResourceKind(arg0 schema.GroupVersionResource, arg1 string, arg2 bool) controller.SharedController {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForResourceKind", arg0, arg1, arg2)
	ret0, _ := ret[0].(controller.SharedController)
	return ret0
}

// ForResourceKind indicates an expected call of ForResourceKind.
func (mr *MockSharedControllerFactoryMockRecorder) ForResourceKind(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForResourceKind", reflect.TypeOf((*MockSharedControllerFactory)(nil).ForResourceKind), arg0, arg1, arg2)
}

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

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

// Start mocks base method.
func (m *MockSharedControllerFactory) Start(arg0 context.Context, arg1 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockSharedController is a mock of SharedController interface.
type MockSharedController struct {
	ctrl     *gomock.Controller
	recorder *MockSharedControllerMockRecorder
}

// MockSharedControllerMockRecorder is the mock recorder for MockSharedController.
type MockSharedControllerMockRecorder struct {
	mock *MockSharedController
}

// NewMockSharedController creates a new mock instance.
func NewMockSharedController(ctrl *gomock.Controller) *MockSharedController {
	mock := &MockSharedController{ctrl: ctrl}
	mock.recorder = &MockSharedControllerMockRecorder{mock}
	return mock
}

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

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

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

// Enqueue mocks base method.
func (m *MockSharedController) Enqueue(arg0, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Enqueue", arg0, arg1)
}

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

// EnqueueAfter mocks base method.
func (m *MockSharedController) EnqueueAfter(arg0, arg1 string, arg2 time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnqueueAfter", arg0, arg1, arg2)
}

// EnqueueAfter indicates an expected call of EnqueueAfter.
func (mr *MockSharedControllerMockRecorder) EnqueueAfter(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueAfter", reflect.TypeOf((*MockSharedController)(nil).EnqueueAfter), arg0, arg1, arg2)
}

// EnqueueKey mocks base method.
func (m *MockSharedController) EnqueueKey(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnqueueKey", arg0)
}

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

// Informer mocks base method.
func (m *MockSharedController) Informer() cache0.SharedIndexInformer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Informer")
	ret0, _ := ret[0].(cache0.SharedIndexInformer)
	return ret0
}

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

// RegisterHandler mocks base method.
func (m *MockSharedController) RegisterHandler(arg0 context.Context, arg1 string, arg2 controller.SharedControllerHandler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterHandler", arg0, arg1, arg2)
}

// RegisterHandler indicates an expected call of RegisterHandler.
func (mr *MockSharedControllerMockRecorder) RegisterHandler(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterHandler", reflect.TypeOf((*MockSharedController)(nil).RegisterHandler), arg0, arg1, arg2)
}

// Start mocks base method.
func (m *MockSharedController) Start(arg0 context.Context, arg1 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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