// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/apimachinery/pkg/api/meta (interfaces: ResettableRESTMapper)
//
// Generated by this command:
//
//	mockgen -typed -destination meta.go -package mock_k8s k8s.io/apimachinery/pkg/api/meta ResettableRESTMapper
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	meta "k8s.io/apimachinery/pkg/api/meta"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
)

// MockResettableRESTMapper is a mock of ResettableRESTMapper interface.
type MockResettableRESTMapper struct {
	ctrl     *gomock.Controller
	recorder *MockResettableRESTMapperMockRecorder
	isgomock struct{}
}

// MockResettableRESTMapperMockRecorder is the mock recorder for MockResettableRESTMapper.
type MockResettableRESTMapperMockRecorder struct {
	mock *MockResettableRESTMapper
}

// NewMockResettableRESTMapper creates a new mock instance.
func NewMockResettableRESTMapper(ctrl *gomock.Controller) *MockResettableRESTMapper {
	mock := &MockResettableRESTMapper{ctrl: ctrl}
	mock.recorder = &MockResettableRESTMapperMockRecorder{mock}
	return mock
}

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

// KindFor mocks base method.
func (m *MockResettableRESTMapper) KindFor(resource schema.GroupVersionResource) (schema.GroupVersionKind, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KindFor", resource)
	ret0, _ := ret[0].(schema.GroupVersionKind)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KindFor indicates an expected call of KindFor.
func (mr *MockResettableRESTMapperMockRecorder) KindFor(resource any) *MockResettableRESTMapperKindForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KindFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).KindFor), resource)
	return &MockResettableRESTMapperKindForCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockResettableRESTMapperKindForCall) Return(arg0 schema.GroupVersionKind, arg1 error) *MockResettableRESTMapperKindForCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockResettableRESTMapperKindForCall) Do(f func(schema.GroupVersionResource) (schema.GroupVersionKind, error)) *MockResettableRESTMapperKindForCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockResettableRESTMapperKindForCall) DoAndReturn(f func(schema.GroupVersionResource) (schema.GroupVersionKind, error)) *MockResettableRESTMapperKindForCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// KindsFor mocks base method.
func (m *MockResettableRESTMapper) KindsFor(resource schema.GroupVersionResource) ([]schema.GroupVersionKind, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KindsFor", resource)
	ret0, _ := ret[0].([]schema.GroupVersionKind)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KindsFor indicates an expected call of KindsFor.
func (mr *MockResettableRESTMapperMockRecorder) KindsFor(resource any) *MockResettableRESTMapperKindsForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KindsFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).KindsFor), resource)
	return &MockResettableRESTMapperKindsForCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockResettableRESTMapperKindsForCall) Do(f func(schema.GroupVersionResource) ([]schema.GroupVersionKind, error)) *MockResettableRESTMapperKindsForCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockResettableRESTMapperKindsForCall) DoAndReturn(f func(schema.GroupVersionResource) ([]schema.GroupVersionKind, error)) *MockResettableRESTMapperKindsForCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RESTMapping mocks base method.
func (m *MockResettableRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	varargs := []any{gk}
	for _, a := range versions {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RESTMapping", varargs...)
	ret0, _ := ret[0].(*meta.RESTMapping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RESTMapping indicates an expected call of RESTMapping.
func (mr *MockResettableRESTMapperMockRecorder) RESTMapping(gk any, versions ...any) *MockResettableRESTMapperRESTMappingCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gk}, versions...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTMapping", reflect.TypeOf((*MockResettableRESTMapper)(nil).RESTMapping), varargs...)
	return &MockResettableRESTMapperRESTMappingCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockResettableRESTMapperRESTMappingCall) Return(arg0 *meta.RESTMapping, arg1 error) *MockResettableRESTMapperRESTMappingCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockResettableRESTMapperRESTMappingCall) Do(f func(schema.GroupKind, ...string) (*meta.RESTMapping, error)) *MockResettableRESTMapperRESTMappingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockResettableRESTMapperRESTMappingCall) DoAndReturn(f func(schema.GroupKind, ...string) (*meta.RESTMapping, error)) *MockResettableRESTMapperRESTMappingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RESTMappings mocks base method.
func (m *MockResettableRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) ([]*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	varargs := []any{gk}
	for _, a := range versions {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RESTMappings", varargs...)
	ret0, _ := ret[0].([]*meta.RESTMapping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RESTMappings indicates an expected call of RESTMappings.
func (mr *MockResettableRESTMapperMockRecorder) RESTMappings(gk any, versions ...any) *MockResettableRESTMapperRESTMappingsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gk}, versions...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTMappings", reflect.TypeOf((*MockResettableRESTMapper)(nil).RESTMappings), varargs...)
	return &MockResettableRESTMapperRESTMappingsCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockResettableRESTMapperRESTMappingsCall) Do(f func(schema.GroupKind, ...string) ([]*meta.RESTMapping, error)) *MockResettableRESTMapperRESTMappingsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockResettableRESTMapperRESTMappingsCall) DoAndReturn(f func(schema.GroupKind, ...string) ([]*meta.RESTMapping, error)) *MockResettableRESTMapperRESTMappingsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Reset mocks base method.
func (m *MockResettableRESTMapper) Reset() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset")
}

// Reset indicates an expected call of Reset.
func (mr *MockResettableRESTMapperMockRecorder) Reset() *MockResettableRESTMapperResetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockResettableRESTMapper)(nil).Reset))
	return &MockResettableRESTMapperResetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockResettableRESTMapperResetCall) Return() *MockResettableRESTMapperResetCall {
	c.Call = c.Call.Return()
	return c
}

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

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

// ResourceFor mocks base method.
func (m *MockResettableRESTMapper) ResourceFor(input schema.GroupVersionResource) (schema.GroupVersionResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourceFor", input)
	ret0, _ := ret[0].(schema.GroupVersionResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResourceFor indicates an expected call of ResourceFor.
func (mr *MockResettableRESTMapperMockRecorder) ResourceFor(input any) *MockResettableRESTMapperResourceForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).ResourceFor), input)
	return &MockResettableRESTMapperResourceForCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockResettableRESTMapperResourceForCall) Return(arg0 schema.GroupVersionResource, arg1 error) *MockResettableRESTMapperResourceForCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockResettableRESTMapperResourceForCall) Do(f func(schema.GroupVersionResource) (schema.GroupVersionResource, error)) *MockResettableRESTMapperResourceForCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockResettableRESTMapperResourceForCall) DoAndReturn(f func(schema.GroupVersionResource) (schema.GroupVersionResource, error)) *MockResettableRESTMapperResourceForCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResourceSingularizer indicates an expected call of ResourceSingularizer.
func (mr *MockResettableRESTMapperMockRecorder) ResourceSingularizer(resource any) *MockResettableRESTMapperResourceSingularizerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceSingularizer", reflect.TypeOf((*MockResettableRESTMapper)(nil).ResourceSingularizer), resource)
	return &MockResettableRESTMapperResourceSingularizerCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockResettableRESTMapperResourceSingularizerCall) Return(singular string, err error) *MockResettableRESTMapperResourceSingularizerCall {
	c.Call = c.Call.Return(singular, err)
	return c
}

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

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

// ResourcesFor mocks base method.
func (m *MockResettableRESTMapper) ResourcesFor(input schema.GroupVersionResource) ([]schema.GroupVersionResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourcesFor", input)
	ret0, _ := ret[0].([]schema.GroupVersionResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResourcesFor indicates an expected call of ResourcesFor.
func (mr *MockResettableRESTMapperMockRecorder) ResourcesFor(input any) *MockResettableRESTMapperResourcesForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourcesFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).ResourcesFor), input)
	return &MockResettableRESTMapperResourcesForCall{Call: call}
}

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

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

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

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