// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/client-go/tools/cache (interfaces: Indexer,GenericLister,GenericNamespaceLister)
//
// Generated by this command:
//
//	mockgen -typed -destination cache.go -package mock_k8s k8s.io/client-go/tools/cache Indexer,GenericLister,GenericNamespaceLister
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	labels "k8s.io/apimachinery/pkg/labels"
	runtime "k8s.io/apimachinery/pkg/runtime"
	cache "k8s.io/client-go/tools/cache"
)

// MockIndexer is a mock of Indexer interface.
type MockIndexer struct {
	ctrl     *gomock.Controller
	recorder *MockIndexerMockRecorder
	isgomock struct{}
}

// MockIndexerMockRecorder is the mock recorder for MockIndexer.
type MockIndexerMockRecorder struct {
	mock *MockIndexer
}

// NewMockIndexer creates a new mock instance.
func NewMockIndexer(ctrl *gomock.Controller) *MockIndexer {
	mock := &MockIndexer{ctrl: ctrl}
	mock.recorder = &MockIndexerMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockIndexer) Add(obj any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockIndexerMockRecorder) Add(obj any) *MockIndexerAddCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockIndexer)(nil).Add), obj)
	return &MockIndexerAddCall{Call: call}
}

// MockIndexerAddCall wrap *gomock.Call
type MockIndexerAddCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerAddCall) Return(arg0 error) *MockIndexerAddCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerAddCall) Do(f func(any) error) *MockIndexerAddCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerAddCall) DoAndReturn(f func(any) error) *MockIndexerAddCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// AddIndexers indicates an expected call of AddIndexers.
func (mr *MockIndexerMockRecorder) AddIndexers(newIndexers any) *MockIndexerAddIndexersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIndexers", reflect.TypeOf((*MockIndexer)(nil).AddIndexers), newIndexers)
	return &MockIndexerAddIndexersCall{Call: call}
}

// MockIndexerAddIndexersCall wrap *gomock.Call
type MockIndexerAddIndexersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerAddIndexersCall) Return(arg0 error) *MockIndexerAddIndexersCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerAddIndexersCall) Do(f func(cache.Indexers) error) *MockIndexerAddIndexersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerAddIndexersCall) DoAndReturn(f func(cache.Indexers) error) *MockIndexerAddIndexersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ByIndex mocks base method.
func (m *MockIndexer) ByIndex(indexName, indexedValue string) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ByIndex", indexName, indexedValue)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ByIndex indicates an expected call of ByIndex.
func (mr *MockIndexerMockRecorder) ByIndex(indexName, indexedValue any) *MockIndexerByIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ByIndex", reflect.TypeOf((*MockIndexer)(nil).ByIndex), indexName, indexedValue)
	return &MockIndexerByIndexCall{Call: call}
}

// MockIndexerByIndexCall wrap *gomock.Call
type MockIndexerByIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerByIndexCall) Return(arg0 []any, arg1 error) *MockIndexerByIndexCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerByIndexCall) Do(f func(string, string) ([]any, error)) *MockIndexerByIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerByIndexCall) DoAndReturn(f func(string, string) ([]any, error)) *MockIndexerByIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Delete mocks base method.
func (m *MockIndexer) Delete(obj any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockIndexerMockRecorder) Delete(obj any) *MockIndexerDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIndexer)(nil).Delete), obj)
	return &MockIndexerDeleteCall{Call: call}
}

// MockIndexerDeleteCall wrap *gomock.Call
type MockIndexerDeleteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerDeleteCall) Return(arg0 error) *MockIndexerDeleteCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerDeleteCall) Do(f func(any) error) *MockIndexerDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerDeleteCall) DoAndReturn(f func(any) error) *MockIndexerDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Get mocks base method.
func (m *MockIndexer) Get(obj any) (any, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", obj)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockIndexerMockRecorder) Get(obj any) *MockIndexerGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIndexer)(nil).Get), obj)
	return &MockIndexerGetCall{Call: call}
}

// MockIndexerGetCall wrap *gomock.Call
type MockIndexerGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerGetCall) Return(item any, exists bool, err error) *MockIndexerGetCall {
	c.Call = c.Call.Return(item, exists, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerGetCall) Do(f func(any) (any, bool, error)) *MockIndexerGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerGetCall) DoAndReturn(f func(any) (any, bool, error)) *MockIndexerGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetByKey mocks base method.
func (m *MockIndexer) GetByKey(key string) (any, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByKey", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByKey indicates an expected call of GetByKey.
func (mr *MockIndexerMockRecorder) GetByKey(key any) *MockIndexerGetByKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByKey", reflect.TypeOf((*MockIndexer)(nil).GetByKey), key)
	return &MockIndexerGetByKeyCall{Call: call}
}

// MockIndexerGetByKeyCall wrap *gomock.Call
type MockIndexerGetByKeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerGetByKeyCall) Return(item any, exists bool, err error) *MockIndexerGetByKeyCall {
	c.Call = c.Call.Return(item, exists, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerGetByKeyCall) Do(f func(string) (any, bool, error)) *MockIndexerGetByKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerGetByKeyCall) DoAndReturn(f func(string) (any, bool, error)) *MockIndexerGetByKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetIndexers indicates an expected call of GetIndexers.
func (mr *MockIndexerMockRecorder) GetIndexers() *MockIndexerGetIndexersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndexers", reflect.TypeOf((*MockIndexer)(nil).GetIndexers))
	return &MockIndexerGetIndexersCall{Call: call}
}

// MockIndexerGetIndexersCall wrap *gomock.Call
type MockIndexerGetIndexersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerGetIndexersCall) Return(arg0 cache.Indexers) *MockIndexerGetIndexersCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerGetIndexersCall) Do(f func() cache.Indexers) *MockIndexerGetIndexersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerGetIndexersCall) DoAndReturn(f func() cache.Indexers) *MockIndexerGetIndexersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Index mocks base method.
func (m *MockIndexer) Index(indexName string, obj any) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Index", indexName, obj)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Index indicates an expected call of Index.
func (mr *MockIndexerMockRecorder) Index(indexName, obj any) *MockIndexerIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Index", reflect.TypeOf((*MockIndexer)(nil).Index), indexName, obj)
	return &MockIndexerIndexCall{Call: call}
}

// MockIndexerIndexCall wrap *gomock.Call
type MockIndexerIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerIndexCall) Return(arg0 []any, arg1 error) *MockIndexerIndexCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerIndexCall) Do(f func(string, any) ([]any, error)) *MockIndexerIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerIndexCall) DoAndReturn(f func(string, any) ([]any, error)) *MockIndexerIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IndexKeys mocks base method.
func (m *MockIndexer) IndexKeys(indexName, indexedValue string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IndexKeys", indexName, indexedValue)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IndexKeys indicates an expected call of IndexKeys.
func (mr *MockIndexerMockRecorder) IndexKeys(indexName, indexedValue any) *MockIndexerIndexKeysCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IndexKeys", reflect.TypeOf((*MockIndexer)(nil).IndexKeys), indexName, indexedValue)
	return &MockIndexerIndexKeysCall{Call: call}
}

// MockIndexerIndexKeysCall wrap *gomock.Call
type MockIndexerIndexKeysCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerIndexKeysCall) Return(arg0 []string, arg1 error) *MockIndexerIndexKeysCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerIndexKeysCall) Do(f func(string, string) ([]string, error)) *MockIndexerIndexKeysCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerIndexKeysCall) DoAndReturn(f func(string, string) ([]string, error)) *MockIndexerIndexKeysCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// List indicates an expected call of List.
func (mr *MockIndexerMockRecorder) List() *MockIndexerListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIndexer)(nil).List))
	return &MockIndexerListCall{Call: call}
}

// MockIndexerListCall wrap *gomock.Call
type MockIndexerListCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerListCall) Return(arg0 []any) *MockIndexerListCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerListCall) Do(f func() []any) *MockIndexerListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerListCall) DoAndReturn(f func() []any) *MockIndexerListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ListIndexFuncValues indicates an expected call of ListIndexFuncValues.
func (mr *MockIndexerMockRecorder) ListIndexFuncValues(indexName any) *MockIndexerListIndexFuncValuesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIndexFuncValues", reflect.TypeOf((*MockIndexer)(nil).ListIndexFuncValues), indexName)
	return &MockIndexerListIndexFuncValuesCall{Call: call}
}

// MockIndexerListIndexFuncValuesCall wrap *gomock.Call
type MockIndexerListIndexFuncValuesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerListIndexFuncValuesCall) Return(arg0 []string) *MockIndexerListIndexFuncValuesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerListIndexFuncValuesCall) Do(f func(string) []string) *MockIndexerListIndexFuncValuesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerListIndexFuncValuesCall) DoAndReturn(f func(string) []string) *MockIndexerListIndexFuncValuesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ListKeys indicates an expected call of ListKeys.
func (mr *MockIndexerMockRecorder) ListKeys() *MockIndexerListKeysCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockIndexer)(nil).ListKeys))
	return &MockIndexerListKeysCall{Call: call}
}

// MockIndexerListKeysCall wrap *gomock.Call
type MockIndexerListKeysCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerListKeysCall) Return(arg0 []string) *MockIndexerListKeysCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerListKeysCall) Do(f func() []string) *MockIndexerListKeysCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerListKeysCall) DoAndReturn(f func() []string) *MockIndexerListKeysCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Replace mocks base method.
func (m *MockIndexer) Replace(arg0 []any, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Replace", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Replace indicates an expected call of Replace.
func (mr *MockIndexerMockRecorder) Replace(arg0, arg1 any) *MockIndexerReplaceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replace", reflect.TypeOf((*MockIndexer)(nil).Replace), arg0, arg1)
	return &MockIndexerReplaceCall{Call: call}
}

// MockIndexerReplaceCall wrap *gomock.Call
type MockIndexerReplaceCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerReplaceCall) Return(arg0 error) *MockIndexerReplaceCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerReplaceCall) Do(f func([]any, string) error) *MockIndexerReplaceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerReplaceCall) DoAndReturn(f func([]any, string) error) *MockIndexerReplaceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Resync indicates an expected call of Resync.
func (mr *MockIndexerMockRecorder) Resync() *MockIndexerResyncCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resync", reflect.TypeOf((*MockIndexer)(nil).Resync))
	return &MockIndexerResyncCall{Call: call}
}

// MockIndexerResyncCall wrap *gomock.Call
type MockIndexerResyncCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerResyncCall) Return(arg0 error) *MockIndexerResyncCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerResyncCall) Do(f func() error) *MockIndexerResyncCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerResyncCall) DoAndReturn(f func() error) *MockIndexerResyncCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Update mocks base method.
func (m *MockIndexer) Update(obj any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockIndexerMockRecorder) Update(obj any) *MockIndexerUpdateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIndexer)(nil).Update), obj)
	return &MockIndexerUpdateCall{Call: call}
}

// MockIndexerUpdateCall wrap *gomock.Call
type MockIndexerUpdateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIndexerUpdateCall) Return(arg0 error) *MockIndexerUpdateCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIndexerUpdateCall) Do(f func(any) error) *MockIndexerUpdateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIndexerUpdateCall) DoAndReturn(f func(any) error) *MockIndexerUpdateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGenericLister is a mock of GenericLister interface.
type MockGenericLister struct {
	ctrl     *gomock.Controller
	recorder *MockGenericListerMockRecorder
	isgomock struct{}
}

// MockGenericListerMockRecorder is the mock recorder for MockGenericLister.
type MockGenericListerMockRecorder struct {
	mock *MockGenericLister
}

// NewMockGenericLister creates a new mock instance.
func NewMockGenericLister(ctrl *gomock.Controller) *MockGenericLister {
	mock := &MockGenericLister{ctrl: ctrl}
	mock.recorder = &MockGenericListerMockRecorder{mock}
	return mock
}

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

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

// ByNamespace indicates an expected call of ByNamespace.
func (mr *MockGenericListerMockRecorder) ByNamespace(namespace any) *MockGenericListerByNamespaceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ByNamespace", reflect.TypeOf((*MockGenericLister)(nil).ByNamespace), namespace)
	return &MockGenericListerByNamespaceCall{Call: call}
}

// MockGenericListerByNamespaceCall wrap *gomock.Call
type MockGenericListerByNamespaceCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGenericListerByNamespaceCall) Return(arg0 cache.GenericNamespaceLister) *MockGenericListerByNamespaceCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGenericListerByNamespaceCall) Do(f func(string) cache.GenericNamespaceLister) *MockGenericListerByNamespaceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGenericListerByNamespaceCall) DoAndReturn(f func(string) cache.GenericNamespaceLister) *MockGenericListerByNamespaceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Get indicates an expected call of Get.
func (mr *MockGenericListerMockRecorder) Get(name any) *MockGenericListerGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockGenericLister)(nil).Get), name)
	return &MockGenericListerGetCall{Call: call}
}

// MockGenericListerGetCall wrap *gomock.Call
type MockGenericListerGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGenericListerGetCall) Return(arg0 runtime.Object, arg1 error) *MockGenericListerGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGenericListerGetCall) Do(f func(string) (runtime.Object, error)) *MockGenericListerGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGenericListerGetCall) DoAndReturn(f func(string) (runtime.Object, error)) *MockGenericListerGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// List indicates an expected call of List.
func (mr *MockGenericListerMockRecorder) List(selector any) *MockGenericListerListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockGenericLister)(nil).List), selector)
	return &MockGenericListerListCall{Call: call}
}

// MockGenericListerListCall wrap *gomock.Call
type MockGenericListerListCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGenericListerListCall) Return(ret []runtime.Object, err error) *MockGenericListerListCall {
	c.Call = c.Call.Return(ret, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGenericListerListCall) Do(f func(labels.Selector) ([]runtime.Object, error)) *MockGenericListerListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGenericListerListCall) DoAndReturn(f func(labels.Selector) ([]runtime.Object, error)) *MockGenericListerListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGenericNamespaceLister is a mock of GenericNamespaceLister interface.
type MockGenericNamespaceLister struct {
	ctrl     *gomock.Controller
	recorder *MockGenericNamespaceListerMockRecorder
	isgomock struct{}
}

// MockGenericNamespaceListerMockRecorder is the mock recorder for MockGenericNamespaceLister.
type MockGenericNamespaceListerMockRecorder struct {
	mock *MockGenericNamespaceLister
}

// NewMockGenericNamespaceLister creates a new mock instance.
func NewMockGenericNamespaceLister(ctrl *gomock.Controller) *MockGenericNamespaceLister {
	mock := &MockGenericNamespaceLister{ctrl: ctrl}
	mock.recorder = &MockGenericNamespaceListerMockRecorder{mock}
	return mock
}

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

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

// Get indicates an expected call of Get.
func (mr *MockGenericNamespaceListerMockRecorder) Get(name any) *MockGenericNamespaceListerGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockGenericNamespaceLister)(nil).Get), name)
	return &MockGenericNamespaceListerGetCall{Call: call}
}

// MockGenericNamespaceListerGetCall wrap *gomock.Call
type MockGenericNamespaceListerGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGenericNamespaceListerGetCall) Return(arg0 runtime.Object, arg1 error) *MockGenericNamespaceListerGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGenericNamespaceListerGetCall) Do(f func(string) (runtime.Object, error)) *MockGenericNamespaceListerGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGenericNamespaceListerGetCall) DoAndReturn(f func(string) (runtime.Object, error)) *MockGenericNamespaceListerGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// List indicates an expected call of List.
func (mr *MockGenericNamespaceListerMockRecorder) List(selector any) *MockGenericNamespaceListerListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockGenericNamespaceLister)(nil).List), selector)
	return &MockGenericNamespaceListerListCall{Call: call}
}

// MockGenericNamespaceListerListCall wrap *gomock.Call
type MockGenericNamespaceListerListCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGenericNamespaceListerListCall) Return(ret []runtime.Object, err error) *MockGenericNamespaceListerListCall {
	c.Call = c.Call.Return(ret, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGenericNamespaceListerListCall) Do(f func(labels.Selector) ([]runtime.Object, error)) *MockGenericNamespaceListerListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGenericNamespaceListerListCall) DoAndReturn(f func(labels.Selector) ([]runtime.Object, error)) *MockGenericNamespaceListerListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
