// 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
}

// 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(arg0 schema.GroupVersionResource) (schema.GroupVersionKind, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KindFor", arg0)
	ret0, _ := ret[0].(schema.GroupVersionKind)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KindFor indicates an expected call of KindFor.
func (mr *MockResettableRESTMapperMockRecorder) KindFor(arg0 any) *MockResettableRESTMapperKindForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KindFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).KindFor), arg0)
	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(arg0 schema.GroupVersionResource) ([]schema.GroupVersionKind, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KindsFor", arg0)
	ret0, _ := ret[0].([]schema.GroupVersionKind)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KindsFor indicates an expected call of KindsFor.
func (mr *MockResettableRESTMapperMockRecorder) KindsFor(arg0 any) *MockResettableRESTMapperKindsForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KindsFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).KindsFor), arg0)
	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(arg0 schema.GroupKind, arg1 ...string) (*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		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(arg0 any, arg1 ...any) *MockResettableRESTMapperRESTMappingCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	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(arg0 schema.GroupKind, arg1 ...string) ([]*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		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(arg0 any, arg1 ...any) *MockResettableRESTMapperRESTMappingsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	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(arg0 schema.GroupVersionResource) (schema.GroupVersionResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourceFor", arg0)
	ret0, _ := ret[0].(schema.GroupVersionResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResourceFor indicates an expected call of ResourceFor.
func (mr *MockResettableRESTMapperMockRecorder) ResourceFor(arg0 any) *MockResettableRESTMapperResourceForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).ResourceFor), arg0)
	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(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourceSingularizer", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockResettableRESTMapperResourceSingularizerCall) Return(arg0 string, arg1 error) *MockResettableRESTMapperResourceSingularizerCall {
	c.Call = c.Call.Return(arg0, arg1)
	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(arg0 schema.GroupVersionResource) ([]schema.GroupVersionResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourcesFor", arg0)
	ret0, _ := ret[0].([]schema.GroupVersionResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResourcesFor indicates an expected call of ResourcesFor.
func (mr *MockResettableRESTMapperMockRecorder) ResourcesFor(arg0 any) *MockResettableRESTMapperResourcesForCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourcesFor", reflect.TypeOf((*MockResettableRESTMapper)(nil).ResourcesFor), arg0)
	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
}