mock_kubernetesClient_test.go

// Code generated by mockery v2.53.0. DO NOT EDIT.

package main

import (
	mock "github.com/stretchr/testify/mock"
	discovery "k8s.io/client-go/discovery"
	v1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1"
	v1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1"
	v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1"
	apiserverinternalv1alpha1 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1"
	appsv1 "k8s.io/client-go/kubernetes/typed/apps/v1"
	appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
	v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
	authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
	authenticationv1alpha1 "k8s.io/client-go/kubernetes/typed/authentication/v1alpha1"
	authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
	authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1"
	authorizationv1beta1 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
	autoscalingv1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
	v2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2"
	v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1"
	v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2"
	batchv1 "k8s.io/client-go/kubernetes/typed/batch/v1"
	batchv1beta1 "k8s.io/client-go/kubernetes/typed/batch/v1beta1"
	certificatesv1 "k8s.io/client-go/kubernetes/typed/certificates/v1"
	certificatesv1alpha1 "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1"
	certificatesv1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
	coordinationv1 "k8s.io/client-go/kubernetes/typed/coordination/v1"
	v1alpha2 "k8s.io/client-go/kubernetes/typed/coordination/v1alpha2"
	coordinationv1beta1 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1"
	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
	discoveryv1 "k8s.io/client-go/kubernetes/typed/discovery/v1"
	discoveryv1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1"
	eventsv1 "k8s.io/client-go/kubernetes/typed/events/v1"
	eventsv1beta1 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
	extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
	flowcontrolv1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1"
	flowcontrolv1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1"
	flowcontrolv1beta2 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2"
	v1beta3 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta3"
	networkingv1 "k8s.io/client-go/kubernetes/typed/networking/v1"
	networkingv1beta1 "k8s.io/client-go/kubernetes/typed/networking/v1beta1"
	nodev1 "k8s.io/client-go/kubernetes/typed/node/v1"
	nodev1alpha1 "k8s.io/client-go/kubernetes/typed/node/v1alpha1"
	nodev1beta1 "k8s.io/client-go/kubernetes/typed/node/v1beta1"
	policyv1 "k8s.io/client-go/kubernetes/typed/policy/v1"
	policyv1beta1 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
	rbacv1 "k8s.io/client-go/kubernetes/typed/rbac/v1"
	rbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
	rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
	resourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
	v1alpha3 "k8s.io/client-go/kubernetes/typed/resource/v1alpha3"
	resourcev1beta1 "k8s.io/client-go/kubernetes/typed/resource/v1beta1"
	resourcev1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
	schedulingv1 "k8s.io/client-go/kubernetes/typed/scheduling/v1"
	schedulingv1alpha1 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
	schedulingv1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
	storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1"
	storagev1alpha1 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1"
	storagev1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
	storagemigrationv1beta1 "k8s.io/client-go/kubernetes/typed/storagemigration/v1beta1"
)

// mockKubernetesClient is an autogenerated mock type for the kubernetesClient type
type mockKubernetesClient struct {
	mock.Mock
}

type mockKubernetesClient_Expecter struct {
	mock *mock.Mock
}

func (_m *mockKubernetesClient) EXPECT() *mockKubernetesClient_Expecter {
	return &mockKubernetesClient_Expecter{mock: &_m.Mock}
}

// AdmissionregistrationV1 provides a mock function with no fields
func (_m *mockKubernetesClient) AdmissionregistrationV1() v1.AdmissionregistrationV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AdmissionregistrationV1")
	}

	var r0 v1.AdmissionregistrationV1Interface
	if rf, ok := ret.Get(0).(func() v1.AdmissionregistrationV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.AdmissionregistrationV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AdmissionregistrationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdmissionregistrationV1'
type mockKubernetesClient_AdmissionregistrationV1_Call struct {
	*mock.Call
}

// AdmissionregistrationV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AdmissionregistrationV1() *mockKubernetesClient_AdmissionregistrationV1_Call {
	return &mockKubernetesClient_AdmissionregistrationV1_Call{Call: _e.mock.On("AdmissionregistrationV1")}
}

func (_c *mockKubernetesClient_AdmissionregistrationV1_Call) Run(run func()) *mockKubernetesClient_AdmissionregistrationV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AdmissionregistrationV1_Call) Return(_a0 v1.AdmissionregistrationV1Interface) *mockKubernetesClient_AdmissionregistrationV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AdmissionregistrationV1_Call) RunAndReturn(run func() v1.AdmissionregistrationV1Interface) *mockKubernetesClient_AdmissionregistrationV1_Call {
	_c.Call.Return(run)
	return _c
}

// AdmissionregistrationV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) AdmissionregistrationV1alpha1() v1alpha1.AdmissionregistrationV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AdmissionregistrationV1alpha1")
	}

	var r0 v1alpha1.AdmissionregistrationV1alpha1Interface
	if rf, ok := ret.Get(0).(func() v1alpha1.AdmissionregistrationV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1alpha1.AdmissionregistrationV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AdmissionregistrationV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdmissionregistrationV1alpha1'
type mockKubernetesClient_AdmissionregistrationV1alpha1_Call struct {
	*mock.Call
}

// AdmissionregistrationV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AdmissionregistrationV1alpha1() *mockKubernetesClient_AdmissionregistrationV1alpha1_Call {
	return &mockKubernetesClient_AdmissionregistrationV1alpha1_Call{Call: _e.mock.On("AdmissionregistrationV1alpha1")}
}

func (_c *mockKubernetesClient_AdmissionregistrationV1alpha1_Call) Run(run func()) *mockKubernetesClient_AdmissionregistrationV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AdmissionregistrationV1alpha1_Call) Return(_a0 v1alpha1.AdmissionregistrationV1alpha1Interface) *mockKubernetesClient_AdmissionregistrationV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AdmissionregistrationV1alpha1_Call) RunAndReturn(run func() v1alpha1.AdmissionregistrationV1alpha1Interface) *mockKubernetesClient_AdmissionregistrationV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// AdmissionregistrationV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) AdmissionregistrationV1beta1() v1beta1.AdmissionregistrationV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AdmissionregistrationV1beta1")
	}

	var r0 v1beta1.AdmissionregistrationV1beta1Interface
	if rf, ok := ret.Get(0).(func() v1beta1.AdmissionregistrationV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1beta1.AdmissionregistrationV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AdmissionregistrationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdmissionregistrationV1beta1'
type mockKubernetesClient_AdmissionregistrationV1beta1_Call struct {
	*mock.Call
}

// AdmissionregistrationV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AdmissionregistrationV1beta1() *mockKubernetesClient_AdmissionregistrationV1beta1_Call {
	return &mockKubernetesClient_AdmissionregistrationV1beta1_Call{Call: _e.mock.On("AdmissionregistrationV1beta1")}
}

func (_c *mockKubernetesClient_AdmissionregistrationV1beta1_Call) Run(run func()) *mockKubernetesClient_AdmissionregistrationV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AdmissionregistrationV1beta1_Call) Return(_a0 v1beta1.AdmissionregistrationV1beta1Interface) *mockKubernetesClient_AdmissionregistrationV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AdmissionregistrationV1beta1_Call) RunAndReturn(run func() v1beta1.AdmissionregistrationV1beta1Interface) *mockKubernetesClient_AdmissionregistrationV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// AppsV1 provides a mock function with no fields
func (_m *mockKubernetesClient) AppsV1() appsv1.AppsV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AppsV1")
	}

	var r0 appsv1.AppsV1Interface
	if rf, ok := ret.Get(0).(func() appsv1.AppsV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(appsv1.AppsV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AppsV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppsV1'
type mockKubernetesClient_AppsV1_Call struct {
	*mock.Call
}

// AppsV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AppsV1() *mockKubernetesClient_AppsV1_Call {
	return &mockKubernetesClient_AppsV1_Call{Call: _e.mock.On("AppsV1")}
}

func (_c *mockKubernetesClient_AppsV1_Call) Run(run func()) *mockKubernetesClient_AppsV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AppsV1_Call) Return(_a0 appsv1.AppsV1Interface) *mockKubernetesClient_AppsV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AppsV1_Call) RunAndReturn(run func() appsv1.AppsV1Interface) *mockKubernetesClient_AppsV1_Call {
	_c.Call.Return(run)
	return _c
}

// AppsV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AppsV1beta1")
	}

	var r0 appsv1beta1.AppsV1beta1Interface
	if rf, ok := ret.Get(0).(func() appsv1beta1.AppsV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(appsv1beta1.AppsV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AppsV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppsV1beta1'
type mockKubernetesClient_AppsV1beta1_Call struct {
	*mock.Call
}

// AppsV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AppsV1beta1() *mockKubernetesClient_AppsV1beta1_Call {
	return &mockKubernetesClient_AppsV1beta1_Call{Call: _e.mock.On("AppsV1beta1")}
}

func (_c *mockKubernetesClient_AppsV1beta1_Call) Run(run func()) *mockKubernetesClient_AppsV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AppsV1beta1_Call) Return(_a0 appsv1beta1.AppsV1beta1Interface) *mockKubernetesClient_AppsV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AppsV1beta1_Call) RunAndReturn(run func() appsv1beta1.AppsV1beta1Interface) *mockKubernetesClient_AppsV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// AppsV1beta2 provides a mock function with no fields
func (_m *mockKubernetesClient) AppsV1beta2() v1beta2.AppsV1beta2Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AppsV1beta2")
	}

	var r0 v1beta2.AppsV1beta2Interface
	if rf, ok := ret.Get(0).(func() v1beta2.AppsV1beta2Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1beta2.AppsV1beta2Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AppsV1beta2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppsV1beta2'
type mockKubernetesClient_AppsV1beta2_Call struct {
	*mock.Call
}

// AppsV1beta2 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AppsV1beta2() *mockKubernetesClient_AppsV1beta2_Call {
	return &mockKubernetesClient_AppsV1beta2_Call{Call: _e.mock.On("AppsV1beta2")}
}

func (_c *mockKubernetesClient_AppsV1beta2_Call) Run(run func()) *mockKubernetesClient_AppsV1beta2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AppsV1beta2_Call) Return(_a0 v1beta2.AppsV1beta2Interface) *mockKubernetesClient_AppsV1beta2_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AppsV1beta2_Call) RunAndReturn(run func() v1beta2.AppsV1beta2Interface) *mockKubernetesClient_AppsV1beta2_Call {
	_c.Call.Return(run)
	return _c
}

// AuthenticationV1 provides a mock function with no fields
func (_m *mockKubernetesClient) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AuthenticationV1")
	}

	var r0 authenticationv1.AuthenticationV1Interface
	if rf, ok := ret.Get(0).(func() authenticationv1.AuthenticationV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authenticationv1.AuthenticationV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AuthenticationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticationV1'
type mockKubernetesClient_AuthenticationV1_Call struct {
	*mock.Call
}

// AuthenticationV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AuthenticationV1() *mockKubernetesClient_AuthenticationV1_Call {
	return &mockKubernetesClient_AuthenticationV1_Call{Call: _e.mock.On("AuthenticationV1")}
}

func (_c *mockKubernetesClient_AuthenticationV1_Call) Run(run func()) *mockKubernetesClient_AuthenticationV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AuthenticationV1_Call) Return(_a0 authenticationv1.AuthenticationV1Interface) *mockKubernetesClient_AuthenticationV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AuthenticationV1_Call) RunAndReturn(run func() authenticationv1.AuthenticationV1Interface) *mockKubernetesClient_AuthenticationV1_Call {
	_c.Call.Return(run)
	return _c
}

// AuthenticationV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) AuthenticationV1alpha1() authenticationv1alpha1.AuthenticationV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AuthenticationV1alpha1")
	}

	var r0 authenticationv1alpha1.AuthenticationV1alpha1Interface
	if rf, ok := ret.Get(0).(func() authenticationv1alpha1.AuthenticationV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authenticationv1alpha1.AuthenticationV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AuthenticationV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticationV1alpha1'
type mockKubernetesClient_AuthenticationV1alpha1_Call struct {
	*mock.Call
}

// AuthenticationV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AuthenticationV1alpha1() *mockKubernetesClient_AuthenticationV1alpha1_Call {
	return &mockKubernetesClient_AuthenticationV1alpha1_Call{Call: _e.mock.On("AuthenticationV1alpha1")}
}

func (_c *mockKubernetesClient_AuthenticationV1alpha1_Call) Run(run func()) *mockKubernetesClient_AuthenticationV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AuthenticationV1alpha1_Call) Return(_a0 authenticationv1alpha1.AuthenticationV1alpha1Interface) *mockKubernetesClient_AuthenticationV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AuthenticationV1alpha1_Call) RunAndReturn(run func() authenticationv1alpha1.AuthenticationV1alpha1Interface) *mockKubernetesClient_AuthenticationV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// AuthenticationV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AuthenticationV1beta1")
	}

	var r0 authenticationv1beta1.AuthenticationV1beta1Interface
	if rf, ok := ret.Get(0).(func() authenticationv1beta1.AuthenticationV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authenticationv1beta1.AuthenticationV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AuthenticationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticationV1beta1'
type mockKubernetesClient_AuthenticationV1beta1_Call struct {
	*mock.Call
}

// AuthenticationV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AuthenticationV1beta1() *mockKubernetesClient_AuthenticationV1beta1_Call {
	return &mockKubernetesClient_AuthenticationV1beta1_Call{Call: _e.mock.On("AuthenticationV1beta1")}
}

func (_c *mockKubernetesClient_AuthenticationV1beta1_Call) Run(run func()) *mockKubernetesClient_AuthenticationV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AuthenticationV1beta1_Call) Return(_a0 authenticationv1beta1.AuthenticationV1beta1Interface) *mockKubernetesClient_AuthenticationV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AuthenticationV1beta1_Call) RunAndReturn(run func() authenticationv1beta1.AuthenticationV1beta1Interface) *mockKubernetesClient_AuthenticationV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// AuthorizationV1 provides a mock function with no fields
func (_m *mockKubernetesClient) AuthorizationV1() authorizationv1.AuthorizationV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AuthorizationV1")
	}

	var r0 authorizationv1.AuthorizationV1Interface
	if rf, ok := ret.Get(0).(func() authorizationv1.AuthorizationV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authorizationv1.AuthorizationV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AuthorizationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizationV1'
type mockKubernetesClient_AuthorizationV1_Call struct {
	*mock.Call
}

// AuthorizationV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AuthorizationV1() *mockKubernetesClient_AuthorizationV1_Call {
	return &mockKubernetesClient_AuthorizationV1_Call{Call: _e.mock.On("AuthorizationV1")}
}

func (_c *mockKubernetesClient_AuthorizationV1_Call) Run(run func()) *mockKubernetesClient_AuthorizationV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AuthorizationV1_Call) Return(_a0 authorizationv1.AuthorizationV1Interface) *mockKubernetesClient_AuthorizationV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AuthorizationV1_Call) RunAndReturn(run func() authorizationv1.AuthorizationV1Interface) *mockKubernetesClient_AuthorizationV1_Call {
	_c.Call.Return(run)
	return _c
}

// AuthorizationV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AuthorizationV1beta1")
	}

	var r0 authorizationv1beta1.AuthorizationV1beta1Interface
	if rf, ok := ret.Get(0).(func() authorizationv1beta1.AuthorizationV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authorizationv1beta1.AuthorizationV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AuthorizationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizationV1beta1'
type mockKubernetesClient_AuthorizationV1beta1_Call struct {
	*mock.Call
}

// AuthorizationV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AuthorizationV1beta1() *mockKubernetesClient_AuthorizationV1beta1_Call {
	return &mockKubernetesClient_AuthorizationV1beta1_Call{Call: _e.mock.On("AuthorizationV1beta1")}
}

func (_c *mockKubernetesClient_AuthorizationV1beta1_Call) Run(run func()) *mockKubernetesClient_AuthorizationV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AuthorizationV1beta1_Call) Return(_a0 authorizationv1beta1.AuthorizationV1beta1Interface) *mockKubernetesClient_AuthorizationV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AuthorizationV1beta1_Call) RunAndReturn(run func() authorizationv1beta1.AuthorizationV1beta1Interface) *mockKubernetesClient_AuthorizationV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// AutoscalingV1 provides a mock function with no fields
func (_m *mockKubernetesClient) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AutoscalingV1")
	}

	var r0 autoscalingv1.AutoscalingV1Interface
	if rf, ok := ret.Get(0).(func() autoscalingv1.AutoscalingV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(autoscalingv1.AutoscalingV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AutoscalingV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV1'
type mockKubernetesClient_AutoscalingV1_Call struct {
	*mock.Call
}

// AutoscalingV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AutoscalingV1() *mockKubernetesClient_AutoscalingV1_Call {
	return &mockKubernetesClient_AutoscalingV1_Call{Call: _e.mock.On("AutoscalingV1")}
}

func (_c *mockKubernetesClient_AutoscalingV1_Call) Run(run func()) *mockKubernetesClient_AutoscalingV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV1_Call) Return(_a0 autoscalingv1.AutoscalingV1Interface) *mockKubernetesClient_AutoscalingV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV1_Call) RunAndReturn(run func() autoscalingv1.AutoscalingV1Interface) *mockKubernetesClient_AutoscalingV1_Call {
	_c.Call.Return(run)
	return _c
}

// AutoscalingV2 provides a mock function with no fields
func (_m *mockKubernetesClient) AutoscalingV2() v2.AutoscalingV2Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AutoscalingV2")
	}

	var r0 v2.AutoscalingV2Interface
	if rf, ok := ret.Get(0).(func() v2.AutoscalingV2Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v2.AutoscalingV2Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AutoscalingV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV2'
type mockKubernetesClient_AutoscalingV2_Call struct {
	*mock.Call
}

// AutoscalingV2 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AutoscalingV2() *mockKubernetesClient_AutoscalingV2_Call {
	return &mockKubernetesClient_AutoscalingV2_Call{Call: _e.mock.On("AutoscalingV2")}
}

func (_c *mockKubernetesClient_AutoscalingV2_Call) Run(run func()) *mockKubernetesClient_AutoscalingV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV2_Call) Return(_a0 v2.AutoscalingV2Interface) *mockKubernetesClient_AutoscalingV2_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV2_Call) RunAndReturn(run func() v2.AutoscalingV2Interface) *mockKubernetesClient_AutoscalingV2_Call {
	_c.Call.Return(run)
	return _c
}

// AutoscalingV2beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) AutoscalingV2beta1() v2beta1.AutoscalingV2beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AutoscalingV2beta1")
	}

	var r0 v2beta1.AutoscalingV2beta1Interface
	if rf, ok := ret.Get(0).(func() v2beta1.AutoscalingV2beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v2beta1.AutoscalingV2beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AutoscalingV2beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV2beta1'
type mockKubernetesClient_AutoscalingV2beta1_Call struct {
	*mock.Call
}

// AutoscalingV2beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AutoscalingV2beta1() *mockKubernetesClient_AutoscalingV2beta1_Call {
	return &mockKubernetesClient_AutoscalingV2beta1_Call{Call: _e.mock.On("AutoscalingV2beta1")}
}

func (_c *mockKubernetesClient_AutoscalingV2beta1_Call) Run(run func()) *mockKubernetesClient_AutoscalingV2beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV2beta1_Call) Return(_a0 v2beta1.AutoscalingV2beta1Interface) *mockKubernetesClient_AutoscalingV2beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV2beta1_Call) RunAndReturn(run func() v2beta1.AutoscalingV2beta1Interface) *mockKubernetesClient_AutoscalingV2beta1_Call {
	_c.Call.Return(run)
	return _c
}

// AutoscalingV2beta2 provides a mock function with no fields
func (_m *mockKubernetesClient) AutoscalingV2beta2() v2beta2.AutoscalingV2beta2Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for AutoscalingV2beta2")
	}

	var r0 v2beta2.AutoscalingV2beta2Interface
	if rf, ok := ret.Get(0).(func() v2beta2.AutoscalingV2beta2Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v2beta2.AutoscalingV2beta2Interface)
		}
	}

	return r0
}

// mockKubernetesClient_AutoscalingV2beta2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV2beta2'
type mockKubernetesClient_AutoscalingV2beta2_Call struct {
	*mock.Call
}

// AutoscalingV2beta2 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) AutoscalingV2beta2() *mockKubernetesClient_AutoscalingV2beta2_Call {
	return &mockKubernetesClient_AutoscalingV2beta2_Call{Call: _e.mock.On("AutoscalingV2beta2")}
}

func (_c *mockKubernetesClient_AutoscalingV2beta2_Call) Run(run func()) *mockKubernetesClient_AutoscalingV2beta2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV2beta2_Call) Return(_a0 v2beta2.AutoscalingV2beta2Interface) *mockKubernetesClient_AutoscalingV2beta2_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_AutoscalingV2beta2_Call) RunAndReturn(run func() v2beta2.AutoscalingV2beta2Interface) *mockKubernetesClient_AutoscalingV2beta2_Call {
	_c.Call.Return(run)
	return _c
}

// BatchV1 provides a mock function with no fields
func (_m *mockKubernetesClient) BatchV1() batchv1.BatchV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for BatchV1")
	}

	var r0 batchv1.BatchV1Interface
	if rf, ok := ret.Get(0).(func() batchv1.BatchV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(batchv1.BatchV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_BatchV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchV1'
type mockKubernetesClient_BatchV1_Call struct {
	*mock.Call
}

// BatchV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) BatchV1() *mockKubernetesClient_BatchV1_Call {
	return &mockKubernetesClient_BatchV1_Call{Call: _e.mock.On("BatchV1")}
}

func (_c *mockKubernetesClient_BatchV1_Call) Run(run func()) *mockKubernetesClient_BatchV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_BatchV1_Call) Return(_a0 batchv1.BatchV1Interface) *mockKubernetesClient_BatchV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_BatchV1_Call) RunAndReturn(run func() batchv1.BatchV1Interface) *mockKubernetesClient_BatchV1_Call {
	_c.Call.Return(run)
	return _c
}

// BatchV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) BatchV1beta1() batchv1beta1.BatchV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for BatchV1beta1")
	}

	var r0 batchv1beta1.BatchV1beta1Interface
	if rf, ok := ret.Get(0).(func() batchv1beta1.BatchV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(batchv1beta1.BatchV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_BatchV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchV1beta1'
type mockKubernetesClient_BatchV1beta1_Call struct {
	*mock.Call
}

// BatchV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) BatchV1beta1() *mockKubernetesClient_BatchV1beta1_Call {
	return &mockKubernetesClient_BatchV1beta1_Call{Call: _e.mock.On("BatchV1beta1")}
}

func (_c *mockKubernetesClient_BatchV1beta1_Call) Run(run func()) *mockKubernetesClient_BatchV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_BatchV1beta1_Call) Return(_a0 batchv1beta1.BatchV1beta1Interface) *mockKubernetesClient_BatchV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_BatchV1beta1_Call) RunAndReturn(run func() batchv1beta1.BatchV1beta1Interface) *mockKubernetesClient_BatchV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// CertificatesV1 provides a mock function with no fields
func (_m *mockKubernetesClient) CertificatesV1() certificatesv1.CertificatesV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CertificatesV1")
	}

	var r0 certificatesv1.CertificatesV1Interface
	if rf, ok := ret.Get(0).(func() certificatesv1.CertificatesV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(certificatesv1.CertificatesV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CertificatesV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CertificatesV1'
type mockKubernetesClient_CertificatesV1_Call struct {
	*mock.Call
}

// CertificatesV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CertificatesV1() *mockKubernetesClient_CertificatesV1_Call {
	return &mockKubernetesClient_CertificatesV1_Call{Call: _e.mock.On("CertificatesV1")}
}

func (_c *mockKubernetesClient_CertificatesV1_Call) Run(run func()) *mockKubernetesClient_CertificatesV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CertificatesV1_Call) Return(_a0 certificatesv1.CertificatesV1Interface) *mockKubernetesClient_CertificatesV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CertificatesV1_Call) RunAndReturn(run func() certificatesv1.CertificatesV1Interface) *mockKubernetesClient_CertificatesV1_Call {
	_c.Call.Return(run)
	return _c
}

// CertificatesV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) CertificatesV1alpha1() certificatesv1alpha1.CertificatesV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CertificatesV1alpha1")
	}

	var r0 certificatesv1alpha1.CertificatesV1alpha1Interface
	if rf, ok := ret.Get(0).(func() certificatesv1alpha1.CertificatesV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(certificatesv1alpha1.CertificatesV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CertificatesV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CertificatesV1alpha1'
type mockKubernetesClient_CertificatesV1alpha1_Call struct {
	*mock.Call
}

// CertificatesV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CertificatesV1alpha1() *mockKubernetesClient_CertificatesV1alpha1_Call {
	return &mockKubernetesClient_CertificatesV1alpha1_Call{Call: _e.mock.On("CertificatesV1alpha1")}
}

func (_c *mockKubernetesClient_CertificatesV1alpha1_Call) Run(run func()) *mockKubernetesClient_CertificatesV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CertificatesV1alpha1_Call) Return(_a0 certificatesv1alpha1.CertificatesV1alpha1Interface) *mockKubernetesClient_CertificatesV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CertificatesV1alpha1_Call) RunAndReturn(run func() certificatesv1alpha1.CertificatesV1alpha1Interface) *mockKubernetesClient_CertificatesV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// CertificatesV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CertificatesV1beta1")
	}

	var r0 certificatesv1beta1.CertificatesV1beta1Interface
	if rf, ok := ret.Get(0).(func() certificatesv1beta1.CertificatesV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(certificatesv1beta1.CertificatesV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CertificatesV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CertificatesV1beta1'
type mockKubernetesClient_CertificatesV1beta1_Call struct {
	*mock.Call
}

// CertificatesV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CertificatesV1beta1() *mockKubernetesClient_CertificatesV1beta1_Call {
	return &mockKubernetesClient_CertificatesV1beta1_Call{Call: _e.mock.On("CertificatesV1beta1")}
}

func (_c *mockKubernetesClient_CertificatesV1beta1_Call) Run(run func()) *mockKubernetesClient_CertificatesV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CertificatesV1beta1_Call) Return(_a0 certificatesv1beta1.CertificatesV1beta1Interface) *mockKubernetesClient_CertificatesV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CertificatesV1beta1_Call) RunAndReturn(run func() certificatesv1beta1.CertificatesV1beta1Interface) *mockKubernetesClient_CertificatesV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// CoordinationV1 provides a mock function with no fields
func (_m *mockKubernetesClient) CoordinationV1() coordinationv1.CoordinationV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CoordinationV1")
	}

	var r0 coordinationv1.CoordinationV1Interface
	if rf, ok := ret.Get(0).(func() coordinationv1.CoordinationV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(coordinationv1.CoordinationV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CoordinationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoordinationV1'
type mockKubernetesClient_CoordinationV1_Call struct {
	*mock.Call
}

// CoordinationV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CoordinationV1() *mockKubernetesClient_CoordinationV1_Call {
	return &mockKubernetesClient_CoordinationV1_Call{Call: _e.mock.On("CoordinationV1")}
}

func (_c *mockKubernetesClient_CoordinationV1_Call) Run(run func()) *mockKubernetesClient_CoordinationV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CoordinationV1_Call) Return(_a0 coordinationv1.CoordinationV1Interface) *mockKubernetesClient_CoordinationV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CoordinationV1_Call) RunAndReturn(run func() coordinationv1.CoordinationV1Interface) *mockKubernetesClient_CoordinationV1_Call {
	_c.Call.Return(run)
	return _c
}

// CoordinationV1alpha2 provides a mock function with no fields
func (_m *mockKubernetesClient) CoordinationV1alpha2() v1alpha2.CoordinationV1alpha2Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CoordinationV1alpha2")
	}

	var r0 v1alpha2.CoordinationV1alpha2Interface
	if rf, ok := ret.Get(0).(func() v1alpha2.CoordinationV1alpha2Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1alpha2.CoordinationV1alpha2Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CoordinationV1alpha2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoordinationV1alpha2'
type mockKubernetesClient_CoordinationV1alpha2_Call struct {
	*mock.Call
}

// CoordinationV1alpha2 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CoordinationV1alpha2() *mockKubernetesClient_CoordinationV1alpha2_Call {
	return &mockKubernetesClient_CoordinationV1alpha2_Call{Call: _e.mock.On("CoordinationV1alpha2")}
}

func (_c *mockKubernetesClient_CoordinationV1alpha2_Call) Run(run func()) *mockKubernetesClient_CoordinationV1alpha2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CoordinationV1alpha2_Call) Return(_a0 v1alpha2.CoordinationV1alpha2Interface) *mockKubernetesClient_CoordinationV1alpha2_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CoordinationV1alpha2_Call) RunAndReturn(run func() v1alpha2.CoordinationV1alpha2Interface) *mockKubernetesClient_CoordinationV1alpha2_Call {
	_c.Call.Return(run)
	return _c
}

// CoordinationV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) CoordinationV1beta1() coordinationv1beta1.CoordinationV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CoordinationV1beta1")
	}

	var r0 coordinationv1beta1.CoordinationV1beta1Interface
	if rf, ok := ret.Get(0).(func() coordinationv1beta1.CoordinationV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(coordinationv1beta1.CoordinationV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CoordinationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoordinationV1beta1'
type mockKubernetesClient_CoordinationV1beta1_Call struct {
	*mock.Call
}

// CoordinationV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CoordinationV1beta1() *mockKubernetesClient_CoordinationV1beta1_Call {
	return &mockKubernetesClient_CoordinationV1beta1_Call{Call: _e.mock.On("CoordinationV1beta1")}
}

func (_c *mockKubernetesClient_CoordinationV1beta1_Call) Run(run func()) *mockKubernetesClient_CoordinationV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CoordinationV1beta1_Call) Return(_a0 coordinationv1beta1.CoordinationV1beta1Interface) *mockKubernetesClient_CoordinationV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CoordinationV1beta1_Call) RunAndReturn(run func() coordinationv1beta1.CoordinationV1beta1Interface) *mockKubernetesClient_CoordinationV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// CoreV1 provides a mock function with no fields
func (_m *mockKubernetesClient) CoreV1() corev1.CoreV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CoreV1")
	}

	var r0 corev1.CoreV1Interface
	if rf, ok := ret.Get(0).(func() corev1.CoreV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(corev1.CoreV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_CoreV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoreV1'
type mockKubernetesClient_CoreV1_Call struct {
	*mock.Call
}

// CoreV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) CoreV1() *mockKubernetesClient_CoreV1_Call {
	return &mockKubernetesClient_CoreV1_Call{Call: _e.mock.On("CoreV1")}
}

func (_c *mockKubernetesClient_CoreV1_Call) Run(run func()) *mockKubernetesClient_CoreV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_CoreV1_Call) Return(_a0 corev1.CoreV1Interface) *mockKubernetesClient_CoreV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_CoreV1_Call) RunAndReturn(run func() corev1.CoreV1Interface) *mockKubernetesClient_CoreV1_Call {
	_c.Call.Return(run)
	return _c
}

// Discovery provides a mock function with no fields
func (_m *mockKubernetesClient) Discovery() discovery.DiscoveryInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Discovery")
	}

	var r0 discovery.DiscoveryInterface
	if rf, ok := ret.Get(0).(func() discovery.DiscoveryInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(discovery.DiscoveryInterface)
		}
	}

	return r0
}

// mockKubernetesClient_Discovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Discovery'
type mockKubernetesClient_Discovery_Call struct {
	*mock.Call
}

// Discovery is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) Discovery() *mockKubernetesClient_Discovery_Call {
	return &mockKubernetesClient_Discovery_Call{Call: _e.mock.On("Discovery")}
}

func (_c *mockKubernetesClient_Discovery_Call) Run(run func()) *mockKubernetesClient_Discovery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_Discovery_Call) Return(_a0 discovery.DiscoveryInterface) *mockKubernetesClient_Discovery_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_Discovery_Call) RunAndReturn(run func() discovery.DiscoveryInterface) *mockKubernetesClient_Discovery_Call {
	_c.Call.Return(run)
	return _c
}

// DiscoveryV1 provides a mock function with no fields
func (_m *mockKubernetesClient) DiscoveryV1() discoveryv1.DiscoveryV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for DiscoveryV1")
	}

	var r0 discoveryv1.DiscoveryV1Interface
	if rf, ok := ret.Get(0).(func() discoveryv1.DiscoveryV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(discoveryv1.DiscoveryV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_DiscoveryV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiscoveryV1'
type mockKubernetesClient_DiscoveryV1_Call struct {
	*mock.Call
}

// DiscoveryV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) DiscoveryV1() *mockKubernetesClient_DiscoveryV1_Call {
	return &mockKubernetesClient_DiscoveryV1_Call{Call: _e.mock.On("DiscoveryV1")}
}

func (_c *mockKubernetesClient_DiscoveryV1_Call) Run(run func()) *mockKubernetesClient_DiscoveryV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_DiscoveryV1_Call) Return(_a0 discoveryv1.DiscoveryV1Interface) *mockKubernetesClient_DiscoveryV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_DiscoveryV1_Call) RunAndReturn(run func() discoveryv1.DiscoveryV1Interface) *mockKubernetesClient_DiscoveryV1_Call {
	_c.Call.Return(run)
	return _c
}

// DiscoveryV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for DiscoveryV1beta1")
	}

	var r0 discoveryv1beta1.DiscoveryV1beta1Interface
	if rf, ok := ret.Get(0).(func() discoveryv1beta1.DiscoveryV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(discoveryv1beta1.DiscoveryV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_DiscoveryV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiscoveryV1beta1'
type mockKubernetesClient_DiscoveryV1beta1_Call struct {
	*mock.Call
}

// DiscoveryV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) DiscoveryV1beta1() *mockKubernetesClient_DiscoveryV1beta1_Call {
	return &mockKubernetesClient_DiscoveryV1beta1_Call{Call: _e.mock.On("DiscoveryV1beta1")}
}

func (_c *mockKubernetesClient_DiscoveryV1beta1_Call) Run(run func()) *mockKubernetesClient_DiscoveryV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_DiscoveryV1beta1_Call) Return(_a0 discoveryv1beta1.DiscoveryV1beta1Interface) *mockKubernetesClient_DiscoveryV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_DiscoveryV1beta1_Call) RunAndReturn(run func() discoveryv1beta1.DiscoveryV1beta1Interface) *mockKubernetesClient_DiscoveryV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// EventsV1 provides a mock function with no fields
func (_m *mockKubernetesClient) EventsV1() eventsv1.EventsV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for EventsV1")
	}

	var r0 eventsv1.EventsV1Interface
	if rf, ok := ret.Get(0).(func() eventsv1.EventsV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(eventsv1.EventsV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_EventsV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsV1'
type mockKubernetesClient_EventsV1_Call struct {
	*mock.Call
}

// EventsV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) EventsV1() *mockKubernetesClient_EventsV1_Call {
	return &mockKubernetesClient_EventsV1_Call{Call: _e.mock.On("EventsV1")}
}

func (_c *mockKubernetesClient_EventsV1_Call) Run(run func()) *mockKubernetesClient_EventsV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_EventsV1_Call) Return(_a0 eventsv1.EventsV1Interface) *mockKubernetesClient_EventsV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_EventsV1_Call) RunAndReturn(run func() eventsv1.EventsV1Interface) *mockKubernetesClient_EventsV1_Call {
	_c.Call.Return(run)
	return _c
}

// EventsV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) EventsV1beta1() eventsv1beta1.EventsV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for EventsV1beta1")
	}

	var r0 eventsv1beta1.EventsV1beta1Interface
	if rf, ok := ret.Get(0).(func() eventsv1beta1.EventsV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(eventsv1beta1.EventsV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_EventsV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsV1beta1'
type mockKubernetesClient_EventsV1beta1_Call struct {
	*mock.Call
}

// EventsV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) EventsV1beta1() *mockKubernetesClient_EventsV1beta1_Call {
	return &mockKubernetesClient_EventsV1beta1_Call{Call: _e.mock.On("EventsV1beta1")}
}

func (_c *mockKubernetesClient_EventsV1beta1_Call) Run(run func()) *mockKubernetesClient_EventsV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_EventsV1beta1_Call) Return(_a0 eventsv1beta1.EventsV1beta1Interface) *mockKubernetesClient_EventsV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_EventsV1beta1_Call) RunAndReturn(run func() eventsv1beta1.EventsV1beta1Interface) *mockKubernetesClient_EventsV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// ExtensionsV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ExtensionsV1beta1")
	}

	var r0 extensionsv1beta1.ExtensionsV1beta1Interface
	if rf, ok := ret.Get(0).(func() extensionsv1beta1.ExtensionsV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(extensionsv1beta1.ExtensionsV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_ExtensionsV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExtensionsV1beta1'
type mockKubernetesClient_ExtensionsV1beta1_Call struct {
	*mock.Call
}

// ExtensionsV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) ExtensionsV1beta1() *mockKubernetesClient_ExtensionsV1beta1_Call {
	return &mockKubernetesClient_ExtensionsV1beta1_Call{Call: _e.mock.On("ExtensionsV1beta1")}
}

func (_c *mockKubernetesClient_ExtensionsV1beta1_Call) Run(run func()) *mockKubernetesClient_ExtensionsV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_ExtensionsV1beta1_Call) Return(_a0 extensionsv1beta1.ExtensionsV1beta1Interface) *mockKubernetesClient_ExtensionsV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_ExtensionsV1beta1_Call) RunAndReturn(run func() extensionsv1beta1.ExtensionsV1beta1Interface) *mockKubernetesClient_ExtensionsV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// FlowcontrolV1 provides a mock function with no fields
func (_m *mockKubernetesClient) FlowcontrolV1() flowcontrolv1.FlowcontrolV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for FlowcontrolV1")
	}

	var r0 flowcontrolv1.FlowcontrolV1Interface
	if rf, ok := ret.Get(0).(func() flowcontrolv1.FlowcontrolV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(flowcontrolv1.FlowcontrolV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_FlowcontrolV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlowcontrolV1'
type mockKubernetesClient_FlowcontrolV1_Call struct {
	*mock.Call
}

// FlowcontrolV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) FlowcontrolV1() *mockKubernetesClient_FlowcontrolV1_Call {
	return &mockKubernetesClient_FlowcontrolV1_Call{Call: _e.mock.On("FlowcontrolV1")}
}

func (_c *mockKubernetesClient_FlowcontrolV1_Call) Run(run func()) *mockKubernetesClient_FlowcontrolV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1_Call) Return(_a0 flowcontrolv1.FlowcontrolV1Interface) *mockKubernetesClient_FlowcontrolV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1_Call) RunAndReturn(run func() flowcontrolv1.FlowcontrolV1Interface) *mockKubernetesClient_FlowcontrolV1_Call {
	_c.Call.Return(run)
	return _c
}

// FlowcontrolV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) FlowcontrolV1beta1() flowcontrolv1beta1.FlowcontrolV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for FlowcontrolV1beta1")
	}

	var r0 flowcontrolv1beta1.FlowcontrolV1beta1Interface
	if rf, ok := ret.Get(0).(func() flowcontrolv1beta1.FlowcontrolV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(flowcontrolv1beta1.FlowcontrolV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_FlowcontrolV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlowcontrolV1beta1'
type mockKubernetesClient_FlowcontrolV1beta1_Call struct {
	*mock.Call
}

// FlowcontrolV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) FlowcontrolV1beta1() *mockKubernetesClient_FlowcontrolV1beta1_Call {
	return &mockKubernetesClient_FlowcontrolV1beta1_Call{Call: _e.mock.On("FlowcontrolV1beta1")}
}

func (_c *mockKubernetesClient_FlowcontrolV1beta1_Call) Run(run func()) *mockKubernetesClient_FlowcontrolV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1beta1_Call) Return(_a0 flowcontrolv1beta1.FlowcontrolV1beta1Interface) *mockKubernetesClient_FlowcontrolV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1beta1_Call) RunAndReturn(run func() flowcontrolv1beta1.FlowcontrolV1beta1Interface) *mockKubernetesClient_FlowcontrolV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// FlowcontrolV1beta2 provides a mock function with no fields
func (_m *mockKubernetesClient) FlowcontrolV1beta2() flowcontrolv1beta2.FlowcontrolV1beta2Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for FlowcontrolV1beta2")
	}

	var r0 flowcontrolv1beta2.FlowcontrolV1beta2Interface
	if rf, ok := ret.Get(0).(func() flowcontrolv1beta2.FlowcontrolV1beta2Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(flowcontrolv1beta2.FlowcontrolV1beta2Interface)
		}
	}

	return r0
}

// mockKubernetesClient_FlowcontrolV1beta2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlowcontrolV1beta2'
type mockKubernetesClient_FlowcontrolV1beta2_Call struct {
	*mock.Call
}

// FlowcontrolV1beta2 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) FlowcontrolV1beta2() *mockKubernetesClient_FlowcontrolV1beta2_Call {
	return &mockKubernetesClient_FlowcontrolV1beta2_Call{Call: _e.mock.On("FlowcontrolV1beta2")}
}

func (_c *mockKubernetesClient_FlowcontrolV1beta2_Call) Run(run func()) *mockKubernetesClient_FlowcontrolV1beta2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1beta2_Call) Return(_a0 flowcontrolv1beta2.FlowcontrolV1beta2Interface) *mockKubernetesClient_FlowcontrolV1beta2_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1beta2_Call) RunAndReturn(run func() flowcontrolv1beta2.FlowcontrolV1beta2Interface) *mockKubernetesClient_FlowcontrolV1beta2_Call {
	_c.Call.Return(run)
	return _c
}

// FlowcontrolV1beta3 provides a mock function with no fields
func (_m *mockKubernetesClient) FlowcontrolV1beta3() v1beta3.FlowcontrolV1beta3Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for FlowcontrolV1beta3")
	}

	var r0 v1beta3.FlowcontrolV1beta3Interface
	if rf, ok := ret.Get(0).(func() v1beta3.FlowcontrolV1beta3Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1beta3.FlowcontrolV1beta3Interface)
		}
	}

	return r0
}

// mockKubernetesClient_FlowcontrolV1beta3_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlowcontrolV1beta3'
type mockKubernetesClient_FlowcontrolV1beta3_Call struct {
	*mock.Call
}

// FlowcontrolV1beta3 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) FlowcontrolV1beta3() *mockKubernetesClient_FlowcontrolV1beta3_Call {
	return &mockKubernetesClient_FlowcontrolV1beta3_Call{Call: _e.mock.On("FlowcontrolV1beta3")}
}

func (_c *mockKubernetesClient_FlowcontrolV1beta3_Call) Run(run func()) *mockKubernetesClient_FlowcontrolV1beta3_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1beta3_Call) Return(_a0 v1beta3.FlowcontrolV1beta3Interface) *mockKubernetesClient_FlowcontrolV1beta3_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_FlowcontrolV1beta3_Call) RunAndReturn(run func() v1beta3.FlowcontrolV1beta3Interface) *mockKubernetesClient_FlowcontrolV1beta3_Call {
	_c.Call.Return(run)
	return _c
}

// InternalV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) InternalV1alpha1() apiserverinternalv1alpha1.InternalV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for InternalV1alpha1")
	}

	var r0 apiserverinternalv1alpha1.InternalV1alpha1Interface
	if rf, ok := ret.Get(0).(func() apiserverinternalv1alpha1.InternalV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(apiserverinternalv1alpha1.InternalV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_InternalV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InternalV1alpha1'
type mockKubernetesClient_InternalV1alpha1_Call struct {
	*mock.Call
}

// InternalV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) InternalV1alpha1() *mockKubernetesClient_InternalV1alpha1_Call {
	return &mockKubernetesClient_InternalV1alpha1_Call{Call: _e.mock.On("InternalV1alpha1")}
}

func (_c *mockKubernetesClient_InternalV1alpha1_Call) Run(run func()) *mockKubernetesClient_InternalV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_InternalV1alpha1_Call) Return(_a0 apiserverinternalv1alpha1.InternalV1alpha1Interface) *mockKubernetesClient_InternalV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_InternalV1alpha1_Call) RunAndReturn(run func() apiserverinternalv1alpha1.InternalV1alpha1Interface) *mockKubernetesClient_InternalV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkingV1 provides a mock function with no fields
func (_m *mockKubernetesClient) NetworkingV1() networkingv1.NetworkingV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for NetworkingV1")
	}

	var r0 networkingv1.NetworkingV1Interface
	if rf, ok := ret.Get(0).(func() networkingv1.NetworkingV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(networkingv1.NetworkingV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_NetworkingV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkingV1'
type mockKubernetesClient_NetworkingV1_Call struct {
	*mock.Call
}

// NetworkingV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) NetworkingV1() *mockKubernetesClient_NetworkingV1_Call {
	return &mockKubernetesClient_NetworkingV1_Call{Call: _e.mock.On("NetworkingV1")}
}

func (_c *mockKubernetesClient_NetworkingV1_Call) Run(run func()) *mockKubernetesClient_NetworkingV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_NetworkingV1_Call) Return(_a0 networkingv1.NetworkingV1Interface) *mockKubernetesClient_NetworkingV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_NetworkingV1_Call) RunAndReturn(run func() networkingv1.NetworkingV1Interface) *mockKubernetesClient_NetworkingV1_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkingV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) NetworkingV1beta1() networkingv1beta1.NetworkingV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for NetworkingV1beta1")
	}

	var r0 networkingv1beta1.NetworkingV1beta1Interface
	if rf, ok := ret.Get(0).(func() networkingv1beta1.NetworkingV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(networkingv1beta1.NetworkingV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_NetworkingV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkingV1beta1'
type mockKubernetesClient_NetworkingV1beta1_Call struct {
	*mock.Call
}

// NetworkingV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) NetworkingV1beta1() *mockKubernetesClient_NetworkingV1beta1_Call {
	return &mockKubernetesClient_NetworkingV1beta1_Call{Call: _e.mock.On("NetworkingV1beta1")}
}

func (_c *mockKubernetesClient_NetworkingV1beta1_Call) Run(run func()) *mockKubernetesClient_NetworkingV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_NetworkingV1beta1_Call) Return(_a0 networkingv1beta1.NetworkingV1beta1Interface) *mockKubernetesClient_NetworkingV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_NetworkingV1beta1_Call) RunAndReturn(run func() networkingv1beta1.NetworkingV1beta1Interface) *mockKubernetesClient_NetworkingV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// NodeV1 provides a mock function with no fields
func (_m *mockKubernetesClient) NodeV1() nodev1.NodeV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for NodeV1")
	}

	var r0 nodev1.NodeV1Interface
	if rf, ok := ret.Get(0).(func() nodev1.NodeV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(nodev1.NodeV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_NodeV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeV1'
type mockKubernetesClient_NodeV1_Call struct {
	*mock.Call
}

// NodeV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) NodeV1() *mockKubernetesClient_NodeV1_Call {
	return &mockKubernetesClient_NodeV1_Call{Call: _e.mock.On("NodeV1")}
}

func (_c *mockKubernetesClient_NodeV1_Call) Run(run func()) *mockKubernetesClient_NodeV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_NodeV1_Call) Return(_a0 nodev1.NodeV1Interface) *mockKubernetesClient_NodeV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_NodeV1_Call) RunAndReturn(run func() nodev1.NodeV1Interface) *mockKubernetesClient_NodeV1_Call {
	_c.Call.Return(run)
	return _c
}

// NodeV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) NodeV1alpha1() nodev1alpha1.NodeV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for NodeV1alpha1")
	}

	var r0 nodev1alpha1.NodeV1alpha1Interface
	if rf, ok := ret.Get(0).(func() nodev1alpha1.NodeV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(nodev1alpha1.NodeV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_NodeV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeV1alpha1'
type mockKubernetesClient_NodeV1alpha1_Call struct {
	*mock.Call
}

// NodeV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) NodeV1alpha1() *mockKubernetesClient_NodeV1alpha1_Call {
	return &mockKubernetesClient_NodeV1alpha1_Call{Call: _e.mock.On("NodeV1alpha1")}
}

func (_c *mockKubernetesClient_NodeV1alpha1_Call) Run(run func()) *mockKubernetesClient_NodeV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_NodeV1alpha1_Call) Return(_a0 nodev1alpha1.NodeV1alpha1Interface) *mockKubernetesClient_NodeV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_NodeV1alpha1_Call) RunAndReturn(run func() nodev1alpha1.NodeV1alpha1Interface) *mockKubernetesClient_NodeV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// NodeV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) NodeV1beta1() nodev1beta1.NodeV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for NodeV1beta1")
	}

	var r0 nodev1beta1.NodeV1beta1Interface
	if rf, ok := ret.Get(0).(func() nodev1beta1.NodeV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(nodev1beta1.NodeV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_NodeV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeV1beta1'
type mockKubernetesClient_NodeV1beta1_Call struct {
	*mock.Call
}

// NodeV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) NodeV1beta1() *mockKubernetesClient_NodeV1beta1_Call {
	return &mockKubernetesClient_NodeV1beta1_Call{Call: _e.mock.On("NodeV1beta1")}
}

func (_c *mockKubernetesClient_NodeV1beta1_Call) Run(run func()) *mockKubernetesClient_NodeV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_NodeV1beta1_Call) Return(_a0 nodev1beta1.NodeV1beta1Interface) *mockKubernetesClient_NodeV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_NodeV1beta1_Call) RunAndReturn(run func() nodev1beta1.NodeV1beta1Interface) *mockKubernetesClient_NodeV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// PolicyV1 provides a mock function with no fields
func (_m *mockKubernetesClient) PolicyV1() policyv1.PolicyV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for PolicyV1")
	}

	var r0 policyv1.PolicyV1Interface
	if rf, ok := ret.Get(0).(func() policyv1.PolicyV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(policyv1.PolicyV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_PolicyV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PolicyV1'
type mockKubernetesClient_PolicyV1_Call struct {
	*mock.Call
}

// PolicyV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) PolicyV1() *mockKubernetesClient_PolicyV1_Call {
	return &mockKubernetesClient_PolicyV1_Call{Call: _e.mock.On("PolicyV1")}
}

func (_c *mockKubernetesClient_PolicyV1_Call) Run(run func()) *mockKubernetesClient_PolicyV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_PolicyV1_Call) Return(_a0 policyv1.PolicyV1Interface) *mockKubernetesClient_PolicyV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_PolicyV1_Call) RunAndReturn(run func() policyv1.PolicyV1Interface) *mockKubernetesClient_PolicyV1_Call {
	_c.Call.Return(run)
	return _c
}

// PolicyV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for PolicyV1beta1")
	}

	var r0 policyv1beta1.PolicyV1beta1Interface
	if rf, ok := ret.Get(0).(func() policyv1beta1.PolicyV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(policyv1beta1.PolicyV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_PolicyV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PolicyV1beta1'
type mockKubernetesClient_PolicyV1beta1_Call struct {
	*mock.Call
}

// PolicyV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) PolicyV1beta1() *mockKubernetesClient_PolicyV1beta1_Call {
	return &mockKubernetesClient_PolicyV1beta1_Call{Call: _e.mock.On("PolicyV1beta1")}
}

func (_c *mockKubernetesClient_PolicyV1beta1_Call) Run(run func()) *mockKubernetesClient_PolicyV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_PolicyV1beta1_Call) Return(_a0 policyv1beta1.PolicyV1beta1Interface) *mockKubernetesClient_PolicyV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_PolicyV1beta1_Call) RunAndReturn(run func() policyv1beta1.PolicyV1beta1Interface) *mockKubernetesClient_PolicyV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// RbacV1 provides a mock function with no fields
func (_m *mockKubernetesClient) RbacV1() rbacv1.RbacV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RbacV1")
	}

	var r0 rbacv1.RbacV1Interface
	if rf, ok := ret.Get(0).(func() rbacv1.RbacV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(rbacv1.RbacV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_RbacV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RbacV1'
type mockKubernetesClient_RbacV1_Call struct {
	*mock.Call
}

// RbacV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) RbacV1() *mockKubernetesClient_RbacV1_Call {
	return &mockKubernetesClient_RbacV1_Call{Call: _e.mock.On("RbacV1")}
}

func (_c *mockKubernetesClient_RbacV1_Call) Run(run func()) *mockKubernetesClient_RbacV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_RbacV1_Call) Return(_a0 rbacv1.RbacV1Interface) *mockKubernetesClient_RbacV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_RbacV1_Call) RunAndReturn(run func() rbacv1.RbacV1Interface) *mockKubernetesClient_RbacV1_Call {
	_c.Call.Return(run)
	return _c
}

// RbacV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RbacV1alpha1")
	}

	var r0 rbacv1alpha1.RbacV1alpha1Interface
	if rf, ok := ret.Get(0).(func() rbacv1alpha1.RbacV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(rbacv1alpha1.RbacV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_RbacV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RbacV1alpha1'
type mockKubernetesClient_RbacV1alpha1_Call struct {
	*mock.Call
}

// RbacV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) RbacV1alpha1() *mockKubernetesClient_RbacV1alpha1_Call {
	return &mockKubernetesClient_RbacV1alpha1_Call{Call: _e.mock.On("RbacV1alpha1")}
}

func (_c *mockKubernetesClient_RbacV1alpha1_Call) Run(run func()) *mockKubernetesClient_RbacV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_RbacV1alpha1_Call) Return(_a0 rbacv1alpha1.RbacV1alpha1Interface) *mockKubernetesClient_RbacV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_RbacV1alpha1_Call) RunAndReturn(run func() rbacv1alpha1.RbacV1alpha1Interface) *mockKubernetesClient_RbacV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// RbacV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RbacV1beta1")
	}

	var r0 rbacv1beta1.RbacV1beta1Interface
	if rf, ok := ret.Get(0).(func() rbacv1beta1.RbacV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(rbacv1beta1.RbacV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_RbacV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RbacV1beta1'
type mockKubernetesClient_RbacV1beta1_Call struct {
	*mock.Call
}

// RbacV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) RbacV1beta1() *mockKubernetesClient_RbacV1beta1_Call {
	return &mockKubernetesClient_RbacV1beta1_Call{Call: _e.mock.On("RbacV1beta1")}
}

func (_c *mockKubernetesClient_RbacV1beta1_Call) Run(run func()) *mockKubernetesClient_RbacV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_RbacV1beta1_Call) Return(_a0 rbacv1beta1.RbacV1beta1Interface) *mockKubernetesClient_RbacV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_RbacV1beta1_Call) RunAndReturn(run func() rbacv1beta1.RbacV1beta1Interface) *mockKubernetesClient_RbacV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceV1 provides a mock function with no fields
func (_m *mockKubernetesClient) ResourceV1() resourcev1.ResourceV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ResourceV1")
	}

	var r0 resourcev1.ResourceV1Interface
	if rf, ok := ret.Get(0).(func() resourcev1.ResourceV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(resourcev1.ResourceV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_ResourceV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceV1'
type mockKubernetesClient_ResourceV1_Call struct {
	*mock.Call
}

// ResourceV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) ResourceV1() *mockKubernetesClient_ResourceV1_Call {
	return &mockKubernetesClient_ResourceV1_Call{Call: _e.mock.On("ResourceV1")}
}

func (_c *mockKubernetesClient_ResourceV1_Call) Run(run func()) *mockKubernetesClient_ResourceV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_ResourceV1_Call) Return(_a0 resourcev1.ResourceV1Interface) *mockKubernetesClient_ResourceV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_ResourceV1_Call) RunAndReturn(run func() resourcev1.ResourceV1Interface) *mockKubernetesClient_ResourceV1_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceV1alpha3 provides a mock function with no fields
func (_m *mockKubernetesClient) ResourceV1alpha3() v1alpha3.ResourceV1alpha3Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ResourceV1alpha3")
	}

	var r0 v1alpha3.ResourceV1alpha3Interface
	if rf, ok := ret.Get(0).(func() v1alpha3.ResourceV1alpha3Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1alpha3.ResourceV1alpha3Interface)
		}
	}

	return r0
}

// mockKubernetesClient_ResourceV1alpha3_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceV1alpha3'
type mockKubernetesClient_ResourceV1alpha3_Call struct {
	*mock.Call
}

// ResourceV1alpha3 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) ResourceV1alpha3() *mockKubernetesClient_ResourceV1alpha3_Call {
	return &mockKubernetesClient_ResourceV1alpha3_Call{Call: _e.mock.On("ResourceV1alpha3")}
}

func (_c *mockKubernetesClient_ResourceV1alpha3_Call) Run(run func()) *mockKubernetesClient_ResourceV1alpha3_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_ResourceV1alpha3_Call) Return(_a0 v1alpha3.ResourceV1alpha3Interface) *mockKubernetesClient_ResourceV1alpha3_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_ResourceV1alpha3_Call) RunAndReturn(run func() v1alpha3.ResourceV1alpha3Interface) *mockKubernetesClient_ResourceV1alpha3_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) ResourceV1beta1() resourcev1beta1.ResourceV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ResourceV1beta1")
	}

	var r0 resourcev1beta1.ResourceV1beta1Interface
	if rf, ok := ret.Get(0).(func() resourcev1beta1.ResourceV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(resourcev1beta1.ResourceV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_ResourceV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceV1beta1'
type mockKubernetesClient_ResourceV1beta1_Call struct {
	*mock.Call
}

// ResourceV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) ResourceV1beta1() *mockKubernetesClient_ResourceV1beta1_Call {
	return &mockKubernetesClient_ResourceV1beta1_Call{Call: _e.mock.On("ResourceV1beta1")}
}

func (_c *mockKubernetesClient_ResourceV1beta1_Call) Run(run func()) *mockKubernetesClient_ResourceV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_ResourceV1beta1_Call) Return(_a0 resourcev1beta1.ResourceV1beta1Interface) *mockKubernetesClient_ResourceV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_ResourceV1beta1_Call) RunAndReturn(run func() resourcev1beta1.ResourceV1beta1Interface) *mockKubernetesClient_ResourceV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceV1beta2 provides a mock function with no fields
func (_m *mockKubernetesClient) ResourceV1beta2() resourcev1beta2.ResourceV1beta2Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ResourceV1beta2")
	}

	var r0 resourcev1beta2.ResourceV1beta2Interface
	if rf, ok := ret.Get(0).(func() resourcev1beta2.ResourceV1beta2Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(resourcev1beta2.ResourceV1beta2Interface)
		}
	}

	return r0
}

// mockKubernetesClient_ResourceV1beta2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceV1beta2'
type mockKubernetesClient_ResourceV1beta2_Call struct {
	*mock.Call
}

// ResourceV1beta2 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) ResourceV1beta2() *mockKubernetesClient_ResourceV1beta2_Call {
	return &mockKubernetesClient_ResourceV1beta2_Call{Call: _e.mock.On("ResourceV1beta2")}
}

func (_c *mockKubernetesClient_ResourceV1beta2_Call) Run(run func()) *mockKubernetesClient_ResourceV1beta2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_ResourceV1beta2_Call) Return(_a0 resourcev1beta2.ResourceV1beta2Interface) *mockKubernetesClient_ResourceV1beta2_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_ResourceV1beta2_Call) RunAndReturn(run func() resourcev1beta2.ResourceV1beta2Interface) *mockKubernetesClient_ResourceV1beta2_Call {
	_c.Call.Return(run)
	return _c
}

// SchedulingV1 provides a mock function with no fields
func (_m *mockKubernetesClient) SchedulingV1() schedulingv1.SchedulingV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for SchedulingV1")
	}

	var r0 schedulingv1.SchedulingV1Interface
	if rf, ok := ret.Get(0).(func() schedulingv1.SchedulingV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(schedulingv1.SchedulingV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_SchedulingV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SchedulingV1'
type mockKubernetesClient_SchedulingV1_Call struct {
	*mock.Call
}

// SchedulingV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) SchedulingV1() *mockKubernetesClient_SchedulingV1_Call {
	return &mockKubernetesClient_SchedulingV1_Call{Call: _e.mock.On("SchedulingV1")}
}

func (_c *mockKubernetesClient_SchedulingV1_Call) Run(run func()) *mockKubernetesClient_SchedulingV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_SchedulingV1_Call) Return(_a0 schedulingv1.SchedulingV1Interface) *mockKubernetesClient_SchedulingV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_SchedulingV1_Call) RunAndReturn(run func() schedulingv1.SchedulingV1Interface) *mockKubernetesClient_SchedulingV1_Call {
	_c.Call.Return(run)
	return _c
}

// SchedulingV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for SchedulingV1alpha1")
	}

	var r0 schedulingv1alpha1.SchedulingV1alpha1Interface
	if rf, ok := ret.Get(0).(func() schedulingv1alpha1.SchedulingV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(schedulingv1alpha1.SchedulingV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_SchedulingV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SchedulingV1alpha1'
type mockKubernetesClient_SchedulingV1alpha1_Call struct {
	*mock.Call
}

// SchedulingV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) SchedulingV1alpha1() *mockKubernetesClient_SchedulingV1alpha1_Call {
	return &mockKubernetesClient_SchedulingV1alpha1_Call{Call: _e.mock.On("SchedulingV1alpha1")}
}

func (_c *mockKubernetesClient_SchedulingV1alpha1_Call) Run(run func()) *mockKubernetesClient_SchedulingV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_SchedulingV1alpha1_Call) Return(_a0 schedulingv1alpha1.SchedulingV1alpha1Interface) *mockKubernetesClient_SchedulingV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_SchedulingV1alpha1_Call) RunAndReturn(run func() schedulingv1alpha1.SchedulingV1alpha1Interface) *mockKubernetesClient_SchedulingV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// SchedulingV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for SchedulingV1beta1")
	}

	var r0 schedulingv1beta1.SchedulingV1beta1Interface
	if rf, ok := ret.Get(0).(func() schedulingv1beta1.SchedulingV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(schedulingv1beta1.SchedulingV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_SchedulingV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SchedulingV1beta1'
type mockKubernetesClient_SchedulingV1beta1_Call struct {
	*mock.Call
}

// SchedulingV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) SchedulingV1beta1() *mockKubernetesClient_SchedulingV1beta1_Call {
	return &mockKubernetesClient_SchedulingV1beta1_Call{Call: _e.mock.On("SchedulingV1beta1")}
}

func (_c *mockKubernetesClient_SchedulingV1beta1_Call) Run(run func()) *mockKubernetesClient_SchedulingV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_SchedulingV1beta1_Call) Return(_a0 schedulingv1beta1.SchedulingV1beta1Interface) *mockKubernetesClient_SchedulingV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_SchedulingV1beta1_Call) RunAndReturn(run func() schedulingv1beta1.SchedulingV1beta1Interface) *mockKubernetesClient_SchedulingV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// StorageV1 provides a mock function with no fields
func (_m *mockKubernetesClient) StorageV1() storagev1.StorageV1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for StorageV1")
	}

	var r0 storagev1.StorageV1Interface
	if rf, ok := ret.Get(0).(func() storagev1.StorageV1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(storagev1.StorageV1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_StorageV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageV1'
type mockKubernetesClient_StorageV1_Call struct {
	*mock.Call
}

// StorageV1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) StorageV1() *mockKubernetesClient_StorageV1_Call {
	return &mockKubernetesClient_StorageV1_Call{Call: _e.mock.On("StorageV1")}
}

func (_c *mockKubernetesClient_StorageV1_Call) Run(run func()) *mockKubernetesClient_StorageV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_StorageV1_Call) Return(_a0 storagev1.StorageV1Interface) *mockKubernetesClient_StorageV1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_StorageV1_Call) RunAndReturn(run func() storagev1.StorageV1Interface) *mockKubernetesClient_StorageV1_Call {
	_c.Call.Return(run)
	return _c
}

// StorageV1alpha1 provides a mock function with no fields
func (_m *mockKubernetesClient) StorageV1alpha1() storagev1alpha1.StorageV1alpha1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for StorageV1alpha1")
	}

	var r0 storagev1alpha1.StorageV1alpha1Interface
	if rf, ok := ret.Get(0).(func() storagev1alpha1.StorageV1alpha1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(storagev1alpha1.StorageV1alpha1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_StorageV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageV1alpha1'
type mockKubernetesClient_StorageV1alpha1_Call struct {
	*mock.Call
}

// StorageV1alpha1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) StorageV1alpha1() *mockKubernetesClient_StorageV1alpha1_Call {
	return &mockKubernetesClient_StorageV1alpha1_Call{Call: _e.mock.On("StorageV1alpha1")}
}

func (_c *mockKubernetesClient_StorageV1alpha1_Call) Run(run func()) *mockKubernetesClient_StorageV1alpha1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_StorageV1alpha1_Call) Return(_a0 storagev1alpha1.StorageV1alpha1Interface) *mockKubernetesClient_StorageV1alpha1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_StorageV1alpha1_Call) RunAndReturn(run func() storagev1alpha1.StorageV1alpha1Interface) *mockKubernetesClient_StorageV1alpha1_Call {
	_c.Call.Return(run)
	return _c
}

// StorageV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) StorageV1beta1() storagev1beta1.StorageV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for StorageV1beta1")
	}

	var r0 storagev1beta1.StorageV1beta1Interface
	if rf, ok := ret.Get(0).(func() storagev1beta1.StorageV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(storagev1beta1.StorageV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_StorageV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageV1beta1'
type mockKubernetesClient_StorageV1beta1_Call struct {
	*mock.Call
}

// StorageV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) StorageV1beta1() *mockKubernetesClient_StorageV1beta1_Call {
	return &mockKubernetesClient_StorageV1beta1_Call{Call: _e.mock.On("StorageV1beta1")}
}

func (_c *mockKubernetesClient_StorageV1beta1_Call) Run(run func()) *mockKubernetesClient_StorageV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_StorageV1beta1_Call) Return(_a0 storagev1beta1.StorageV1beta1Interface) *mockKubernetesClient_StorageV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_StorageV1beta1_Call) RunAndReturn(run func() storagev1beta1.StorageV1beta1Interface) *mockKubernetesClient_StorageV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// StoragemigrationV1beta1 provides a mock function with no fields
func (_m *mockKubernetesClient) StoragemigrationV1beta1() storagemigrationv1beta1.StoragemigrationV1beta1Interface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for StoragemigrationV1beta1")
	}

	var r0 storagemigrationv1beta1.StoragemigrationV1beta1Interface
	if rf, ok := ret.Get(0).(func() storagemigrationv1beta1.StoragemigrationV1beta1Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(storagemigrationv1beta1.StoragemigrationV1beta1Interface)
		}
	}

	return r0
}

// mockKubernetesClient_StoragemigrationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StoragemigrationV1beta1'
type mockKubernetesClient_StoragemigrationV1beta1_Call struct {
	*mock.Call
}

// StoragemigrationV1beta1 is a helper method to define mock.On call
func (_e *mockKubernetesClient_Expecter) StoragemigrationV1beta1() *mockKubernetesClient_StoragemigrationV1beta1_Call {
	return &mockKubernetesClient_StoragemigrationV1beta1_Call{Call: _e.mock.On("StoragemigrationV1beta1")}
}

func (_c *mockKubernetesClient_StoragemigrationV1beta1_Call) Run(run func()) *mockKubernetesClient_StoragemigrationV1beta1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockKubernetesClient_StoragemigrationV1beta1_Call) Return(_a0 storagemigrationv1beta1.StoragemigrationV1beta1Interface) *mockKubernetesClient_StoragemigrationV1beta1_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockKubernetesClient_StoragemigrationV1beta1_Call) RunAndReturn(run func() storagemigrationv1beta1.StoragemigrationV1beta1Interface) *mockKubernetesClient_StoragemigrationV1beta1_Call {
	_c.Call.Return(run)
	return _c
}

// newMockKubernetesClient creates a new instance of mockKubernetesClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func newMockKubernetesClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockKubernetesClient {
	mock := &mockKubernetesClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}