// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/client-go/tools/cache (interfaces: SharedIndexInformer)
//
// Generated by this command:
//
//  	mockgen -self_package github.com/k3s-io/k3s/tests/mock -package mock -mock_names SharedIndexInformer=SharedIndexInformer k8s.io/client-go/tools/cache SharedIndexInformer
//

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

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

	gomock "go.uber.org/mock/gomock"
	cache "k8s.io/client-go/tools/cache"
)

// SharedIndexInformer is a mock of SharedIndexInformer interface.
type SharedIndexInformer struct {
	ctrl     *gomock.Controller
	recorder *SharedIndexInformerMockRecorder
	isgomock struct{}
}

// SharedIndexInformerMockRecorder is the mock recorder for SharedIndexInformer.
type SharedIndexInformerMockRecorder struct {
	mock *SharedIndexInformer
}

// NewSharedIndexInformer creates a new mock instance.
func NewSharedIndexInformer(ctrl *gomock.Controller) *SharedIndexInformer {
	mock := &SharedIndexInformer{ctrl: ctrl}
	mock.recorder = &SharedIndexInformerMockRecorder{mock}
	return mock
}

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

// AddEventHandler mocks base method.
func (m *SharedIndexInformer) AddEventHandler(handler cache.ResourceEventHandler) (cache.ResourceEventHandlerRegistration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEventHandler", handler)
	ret0, _ := ret[0].(cache.ResourceEventHandlerRegistration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddEventHandler indicates an expected call of AddEventHandler.
func (mr *SharedIndexInformerMockRecorder) AddEventHandler(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventHandler", reflect.TypeOf((*SharedIndexInformer)(nil).AddEventHandler), handler)
}

// AddEventHandlerWithOptions mocks base method.
func (m *SharedIndexInformer) AddEventHandlerWithOptions(handler cache.ResourceEventHandler, options cache.HandlerOptions) (cache.ResourceEventHandlerRegistration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEventHandlerWithOptions", handler, options)
	ret0, _ := ret[0].(cache.ResourceEventHandlerRegistration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddEventHandlerWithOptions indicates an expected call of AddEventHandlerWithOptions.
func (mr *SharedIndexInformerMockRecorder) AddEventHandlerWithOptions(handler, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventHandlerWithOptions", reflect.TypeOf((*SharedIndexInformer)(nil).AddEventHandlerWithOptions), handler, options)
}

// AddEventHandlerWithResyncPeriod mocks base method.
func (m *SharedIndexInformer) AddEventHandlerWithResyncPeriod(handler cache.ResourceEventHandler, resyncPeriod time.Duration) (cache.ResourceEventHandlerRegistration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEventHandlerWithResyncPeriod", handler, resyncPeriod)
	ret0, _ := ret[0].(cache.ResourceEventHandlerRegistration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddEventHandlerWithResyncPeriod indicates an expected call of AddEventHandlerWithResyncPeriod.
func (mr *SharedIndexInformerMockRecorder) AddEventHandlerWithResyncPeriod(handler, resyncPeriod any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventHandlerWithResyncPeriod", reflect.TypeOf((*SharedIndexInformer)(nil).AddEventHandlerWithResyncPeriod), handler, resyncPeriod)
}

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

// AddIndexers indicates an expected call of AddIndexers.
func (mr *SharedIndexInformerMockRecorder) AddIndexers(indexers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIndexers", reflect.TypeOf((*SharedIndexInformer)(nil).AddIndexers), indexers)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RemoveEventHandler indicates an expected call of RemoveEventHandler.
func (mr *SharedIndexInformerMockRecorder) RemoveEventHandler(handle any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveEventHandler", reflect.TypeOf((*SharedIndexInformer)(nil).RemoveEventHandler), handle)
}

// Run mocks base method.
func (m *SharedIndexInformer) Run(stopCh <-chan struct{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Run", stopCh)
}

// Run indicates an expected call of Run.
func (mr *SharedIndexInformerMockRecorder) Run(stopCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*SharedIndexInformer)(nil).Run), stopCh)
}

// RunWithContext mocks base method.
func (m *SharedIndexInformer) RunWithContext(ctx context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RunWithContext", ctx)
}

// RunWithContext indicates an expected call of RunWithContext.
func (mr *SharedIndexInformerMockRecorder) RunWithContext(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunWithContext", reflect.TypeOf((*SharedIndexInformer)(nil).RunWithContext), ctx)
}

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

// SetTransform indicates an expected call of SetTransform.
func (mr *SharedIndexInformerMockRecorder) SetTransform(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTransform", reflect.TypeOf((*SharedIndexInformer)(nil).SetTransform), handler)
}

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

// SetWatchErrorHandler indicates an expected call of SetWatchErrorHandler.
func (mr *SharedIndexInformerMockRecorder) SetWatchErrorHandler(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWatchErrorHandler", reflect.TypeOf((*SharedIndexInformer)(nil).SetWatchErrorHandler), handler)
}

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

// SetWatchErrorHandlerWithContext indicates an expected call of SetWatchErrorHandlerWithContext.
func (mr *SharedIndexInformerMockRecorder) SetWatchErrorHandlerWithContext(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWatchErrorHandlerWithContext", reflect.TypeOf((*SharedIndexInformer)(nil).SetWatchErrorHandlerWithContext), handler)
}
