actions-runner-controller/controllers/actions.github.com/mocks_test.go

// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package actionsgithubcom

import (
	"context"

	"github.com/actions/actions-runner-controller/apis/actions.github.com/v1alpha1/appconfig"
	"github.com/actions/actions-runner-controller/controllers/actions.github.com/multiclient"
	"github.com/actions/actions-runner-controller/controllers/actions.github.com/object"
	mock "github.com/stretchr/testify/mock"
	"k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/types"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

// newMockkubernetesObject creates a new instance of mockkubernetesObject. 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 newMockkubernetesObject[T client.Object](t interface {
	mock.TestingT
	Cleanup(func())
}) *mockkubernetesObject[T] {
	mock := &mockkubernetesObject[T]{}
	mock.Mock.Test(t)

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

	return mock
}

// mockkubernetesObject is an autogenerated mock type for the kubernetesObject type
type mockkubernetesObject[T client.Object] struct {
	mock.Mock
}

type mockkubernetesObject_Expecter[T client.Object] struct {
	mock *mock.Mock
}

func (_m *mockkubernetesObject[T]) EXPECT() *mockkubernetesObject_Expecter[T] {
	return &mockkubernetesObject_Expecter[T]{mock: &_m.Mock}
}

// DeepCopy provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) DeepCopy() T {
	ret := _mock.Called()

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

	var r0 T
	if returnFunc, ok := ret.Get(0).(func() T); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(T)
		}
	}
	return r0
}

// mockkubernetesObject_DeepCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeepCopy'
type mockkubernetesObject_DeepCopy_Call[T client.Object] struct {
	*mock.Call
}

// DeepCopy is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) DeepCopy() *mockkubernetesObject_DeepCopy_Call[T] {
	return &mockkubernetesObject_DeepCopy_Call[T]{Call: _e.mock.On("DeepCopy")}
}

func (_c *mockkubernetesObject_DeepCopy_Call[T]) Run(run func()) *mockkubernetesObject_DeepCopy_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_DeepCopy_Call[T]) Return(v T) *mockkubernetesObject_DeepCopy_Call[T] {
	_c.Call.Return(v)
	return _c
}

func (_c *mockkubernetesObject_DeepCopy_Call[T]) RunAndReturn(run func() T) *mockkubernetesObject_DeepCopy_Call[T] {
	_c.Call.Return(run)
	return _c
}

// DeepCopyObject provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) DeepCopyObject() runtime.Object {
	ret := _mock.Called()

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

	var r0 runtime.Object
	if returnFunc, ok := ret.Get(0).(func() runtime.Object); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(runtime.Object)
		}
	}
	return r0
}

// mockkubernetesObject_DeepCopyObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeepCopyObject'
type mockkubernetesObject_DeepCopyObject_Call[T client.Object] struct {
	*mock.Call
}

// DeepCopyObject is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) DeepCopyObject() *mockkubernetesObject_DeepCopyObject_Call[T] {
	return &mockkubernetesObject_DeepCopyObject_Call[T]{Call: _e.mock.On("DeepCopyObject")}
}

func (_c *mockkubernetesObject_DeepCopyObject_Call[T]) Run(run func()) *mockkubernetesObject_DeepCopyObject_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_DeepCopyObject_Call[T]) Return(object runtime.Object) *mockkubernetesObject_DeepCopyObject_Call[T] {
	_c.Call.Return(object)
	return _c
}

func (_c *mockkubernetesObject_DeepCopyObject_Call[T]) RunAndReturn(run func() runtime.Object) *mockkubernetesObject_DeepCopyObject_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetAnnotations provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetAnnotations() map[string]string {
	ret := _mock.Called()

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

	var r0 map[string]string
	if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	return r0
}

// mockkubernetesObject_GetAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnnotations'
type mockkubernetesObject_GetAnnotations_Call[T client.Object] struct {
	*mock.Call
}

// GetAnnotations is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetAnnotations() *mockkubernetesObject_GetAnnotations_Call[T] {
	return &mockkubernetesObject_GetAnnotations_Call[T]{Call: _e.mock.On("GetAnnotations")}
}

func (_c *mockkubernetesObject_GetAnnotations_Call[T]) Run(run func()) *mockkubernetesObject_GetAnnotations_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetAnnotations_Call[T]) Return(stringToString map[string]string) *mockkubernetesObject_GetAnnotations_Call[T] {
	_c.Call.Return(stringToString)
	return _c
}

func (_c *mockkubernetesObject_GetAnnotations_Call[T]) RunAndReturn(run func() map[string]string) *mockkubernetesObject_GetAnnotations_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetCreationTimestamp provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetCreationTimestamp() v1.Time {
	ret := _mock.Called()

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

	var r0 v1.Time
	if returnFunc, ok := ret.Get(0).(func() v1.Time); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(v1.Time)
	}
	return r0
}

// mockkubernetesObject_GetCreationTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreationTimestamp'
type mockkubernetesObject_GetCreationTimestamp_Call[T client.Object] struct {
	*mock.Call
}

// GetCreationTimestamp is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetCreationTimestamp() *mockkubernetesObject_GetCreationTimestamp_Call[T] {
	return &mockkubernetesObject_GetCreationTimestamp_Call[T]{Call: _e.mock.On("GetCreationTimestamp")}
}

func (_c *mockkubernetesObject_GetCreationTimestamp_Call[T]) Run(run func()) *mockkubernetesObject_GetCreationTimestamp_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetCreationTimestamp_Call[T]) Return(time v1.Time) *mockkubernetesObject_GetCreationTimestamp_Call[T] {
	_c.Call.Return(time)
	return _c
}

func (_c *mockkubernetesObject_GetCreationTimestamp_Call[T]) RunAndReturn(run func() v1.Time) *mockkubernetesObject_GetCreationTimestamp_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetDeletionGracePeriodSeconds provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetDeletionGracePeriodSeconds() *int64 {
	ret := _mock.Called()

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

	var r0 *int64
	if returnFunc, ok := ret.Get(0).(func() *int64); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*int64)
		}
	}
	return r0
}

// mockkubernetesObject_GetDeletionGracePeriodSeconds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeletionGracePeriodSeconds'
type mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T client.Object] struct {
	*mock.Call
}

// GetDeletionGracePeriodSeconds is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetDeletionGracePeriodSeconds() *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T] {
	return &mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T]{Call: _e.mock.On("GetDeletionGracePeriodSeconds")}
}

func (_c *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T]) Run(run func()) *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T]) Return(n *int64) *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T] {
	_c.Call.Return(n)
	return _c
}

func (_c *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T]) RunAndReturn(run func() *int64) *mockkubernetesObject_GetDeletionGracePeriodSeconds_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetDeletionTimestamp provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetDeletionTimestamp() *v1.Time {
	ret := _mock.Called()

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

	var r0 *v1.Time
	if returnFunc, ok := ret.Get(0).(func() *v1.Time); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1.Time)
		}
	}
	return r0
}

// mockkubernetesObject_GetDeletionTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeletionTimestamp'
type mockkubernetesObject_GetDeletionTimestamp_Call[T client.Object] struct {
	*mock.Call
}

// GetDeletionTimestamp is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetDeletionTimestamp() *mockkubernetesObject_GetDeletionTimestamp_Call[T] {
	return &mockkubernetesObject_GetDeletionTimestamp_Call[T]{Call: _e.mock.On("GetDeletionTimestamp")}
}

func (_c *mockkubernetesObject_GetDeletionTimestamp_Call[T]) Run(run func()) *mockkubernetesObject_GetDeletionTimestamp_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetDeletionTimestamp_Call[T]) Return(time *v1.Time) *mockkubernetesObject_GetDeletionTimestamp_Call[T] {
	_c.Call.Return(time)
	return _c
}

func (_c *mockkubernetesObject_GetDeletionTimestamp_Call[T]) RunAndReturn(run func() *v1.Time) *mockkubernetesObject_GetDeletionTimestamp_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetFinalizers provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetFinalizers() []string {
	ret := _mock.Called()

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

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

// mockkubernetesObject_GetFinalizers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFinalizers'
type mockkubernetesObject_GetFinalizers_Call[T client.Object] struct {
	*mock.Call
}

// GetFinalizers is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetFinalizers() *mockkubernetesObject_GetFinalizers_Call[T] {
	return &mockkubernetesObject_GetFinalizers_Call[T]{Call: _e.mock.On("GetFinalizers")}
}

func (_c *mockkubernetesObject_GetFinalizers_Call[T]) Run(run func()) *mockkubernetesObject_GetFinalizers_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetFinalizers_Call[T]) Return(strings []string) *mockkubernetesObject_GetFinalizers_Call[T] {
	_c.Call.Return(strings)
	return _c
}

func (_c *mockkubernetesObject_GetFinalizers_Call[T]) RunAndReturn(run func() []string) *mockkubernetesObject_GetFinalizers_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetGenerateName provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetGenerateName() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// mockkubernetesObject_GetGenerateName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGenerateName'
type mockkubernetesObject_GetGenerateName_Call[T client.Object] struct {
	*mock.Call
}

// GetGenerateName is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetGenerateName() *mockkubernetesObject_GetGenerateName_Call[T] {
	return &mockkubernetesObject_GetGenerateName_Call[T]{Call: _e.mock.On("GetGenerateName")}
}

func (_c *mockkubernetesObject_GetGenerateName_Call[T]) Run(run func()) *mockkubernetesObject_GetGenerateName_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetGenerateName_Call[T]) Return(s string) *mockkubernetesObject_GetGenerateName_Call[T] {
	_c.Call.Return(s)
	return _c
}

func (_c *mockkubernetesObject_GetGenerateName_Call[T]) RunAndReturn(run func() string) *mockkubernetesObject_GetGenerateName_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetGeneration provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetGeneration() int64 {
	ret := _mock.Called()

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

	var r0 int64
	if returnFunc, ok := ret.Get(0).(func() int64); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int64)
	}
	return r0
}

// mockkubernetesObject_GetGeneration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGeneration'
type mockkubernetesObject_GetGeneration_Call[T client.Object] struct {
	*mock.Call
}

// GetGeneration is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetGeneration() *mockkubernetesObject_GetGeneration_Call[T] {
	return &mockkubernetesObject_GetGeneration_Call[T]{Call: _e.mock.On("GetGeneration")}
}

func (_c *mockkubernetesObject_GetGeneration_Call[T]) Run(run func()) *mockkubernetesObject_GetGeneration_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetGeneration_Call[T]) Return(n int64) *mockkubernetesObject_GetGeneration_Call[T] {
	_c.Call.Return(n)
	return _c
}

func (_c *mockkubernetesObject_GetGeneration_Call[T]) RunAndReturn(run func() int64) *mockkubernetesObject_GetGeneration_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetLabels provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetLabels() map[string]string {
	ret := _mock.Called()

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

	var r0 map[string]string
	if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	return r0
}

// mockkubernetesObject_GetLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabels'
type mockkubernetesObject_GetLabels_Call[T client.Object] struct {
	*mock.Call
}

// GetLabels is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetLabels() *mockkubernetesObject_GetLabels_Call[T] {
	return &mockkubernetesObject_GetLabels_Call[T]{Call: _e.mock.On("GetLabels")}
}

func (_c *mockkubernetesObject_GetLabels_Call[T]) Run(run func()) *mockkubernetesObject_GetLabels_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetLabels_Call[T]) Return(stringToString map[string]string) *mockkubernetesObject_GetLabels_Call[T] {
	_c.Call.Return(stringToString)
	return _c
}

func (_c *mockkubernetesObject_GetLabels_Call[T]) RunAndReturn(run func() map[string]string) *mockkubernetesObject_GetLabels_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetManagedFields provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetManagedFields() []v1.ManagedFieldsEntry {
	ret := _mock.Called()

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

	var r0 []v1.ManagedFieldsEntry
	if returnFunc, ok := ret.Get(0).(func() []v1.ManagedFieldsEntry); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v1.ManagedFieldsEntry)
		}
	}
	return r0
}

// mockkubernetesObject_GetManagedFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedFields'
type mockkubernetesObject_GetManagedFields_Call[T client.Object] struct {
	*mock.Call
}

// GetManagedFields is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetManagedFields() *mockkubernetesObject_GetManagedFields_Call[T] {
	return &mockkubernetesObject_GetManagedFields_Call[T]{Call: _e.mock.On("GetManagedFields")}
}

func (_c *mockkubernetesObject_GetManagedFields_Call[T]) Run(run func()) *mockkubernetesObject_GetManagedFields_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetManagedFields_Call[T]) Return(managedFieldsEntrys []v1.ManagedFieldsEntry) *mockkubernetesObject_GetManagedFields_Call[T] {
	_c.Call.Return(managedFieldsEntrys)
	return _c
}

func (_c *mockkubernetesObject_GetManagedFields_Call[T]) RunAndReturn(run func() []v1.ManagedFieldsEntry) *mockkubernetesObject_GetManagedFields_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetName provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetName() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// mockkubernetesObject_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName'
type mockkubernetesObject_GetName_Call[T client.Object] struct {
	*mock.Call
}

// GetName is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetName() *mockkubernetesObject_GetName_Call[T] {
	return &mockkubernetesObject_GetName_Call[T]{Call: _e.mock.On("GetName")}
}

func (_c *mockkubernetesObject_GetName_Call[T]) Run(run func()) *mockkubernetesObject_GetName_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetName_Call[T]) Return(s string) *mockkubernetesObject_GetName_Call[T] {
	_c.Call.Return(s)
	return _c
}

func (_c *mockkubernetesObject_GetName_Call[T]) RunAndReturn(run func() string) *mockkubernetesObject_GetName_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetNamespace provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetNamespace() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// mockkubernetesObject_GetNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNamespace'
type mockkubernetesObject_GetNamespace_Call[T client.Object] struct {
	*mock.Call
}

// GetNamespace is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetNamespace() *mockkubernetesObject_GetNamespace_Call[T] {
	return &mockkubernetesObject_GetNamespace_Call[T]{Call: _e.mock.On("GetNamespace")}
}

func (_c *mockkubernetesObject_GetNamespace_Call[T]) Run(run func()) *mockkubernetesObject_GetNamespace_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetNamespace_Call[T]) Return(s string) *mockkubernetesObject_GetNamespace_Call[T] {
	_c.Call.Return(s)
	return _c
}

func (_c *mockkubernetesObject_GetNamespace_Call[T]) RunAndReturn(run func() string) *mockkubernetesObject_GetNamespace_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetObjectKind provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetObjectKind() schema.ObjectKind {
	ret := _mock.Called()

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

	var r0 schema.ObjectKind
	if returnFunc, ok := ret.Get(0).(func() schema.ObjectKind); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(schema.ObjectKind)
		}
	}
	return r0
}

// mockkubernetesObject_GetObjectKind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectKind'
type mockkubernetesObject_GetObjectKind_Call[T client.Object] struct {
	*mock.Call
}

// GetObjectKind is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetObjectKind() *mockkubernetesObject_GetObjectKind_Call[T] {
	return &mockkubernetesObject_GetObjectKind_Call[T]{Call: _e.mock.On("GetObjectKind")}
}

func (_c *mockkubernetesObject_GetObjectKind_Call[T]) Run(run func()) *mockkubernetesObject_GetObjectKind_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetObjectKind_Call[T]) Return(objectKind schema.ObjectKind) *mockkubernetesObject_GetObjectKind_Call[T] {
	_c.Call.Return(objectKind)
	return _c
}

func (_c *mockkubernetesObject_GetObjectKind_Call[T]) RunAndReturn(run func() schema.ObjectKind) *mockkubernetesObject_GetObjectKind_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetOwnerReferences provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetOwnerReferences() []v1.OwnerReference {
	ret := _mock.Called()

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

	var r0 []v1.OwnerReference
	if returnFunc, ok := ret.Get(0).(func() []v1.OwnerReference); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v1.OwnerReference)
		}
	}
	return r0
}

// mockkubernetesObject_GetOwnerReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOwnerReferences'
type mockkubernetesObject_GetOwnerReferences_Call[T client.Object] struct {
	*mock.Call
}

// GetOwnerReferences is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetOwnerReferences() *mockkubernetesObject_GetOwnerReferences_Call[T] {
	return &mockkubernetesObject_GetOwnerReferences_Call[T]{Call: _e.mock.On("GetOwnerReferences")}
}

func (_c *mockkubernetesObject_GetOwnerReferences_Call[T]) Run(run func()) *mockkubernetesObject_GetOwnerReferences_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetOwnerReferences_Call[T]) Return(ownerReferences []v1.OwnerReference) *mockkubernetesObject_GetOwnerReferences_Call[T] {
	_c.Call.Return(ownerReferences)
	return _c
}

func (_c *mockkubernetesObject_GetOwnerReferences_Call[T]) RunAndReturn(run func() []v1.OwnerReference) *mockkubernetesObject_GetOwnerReferences_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetResourceVersion provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetResourceVersion() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// mockkubernetesObject_GetResourceVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResourceVersion'
type mockkubernetesObject_GetResourceVersion_Call[T client.Object] struct {
	*mock.Call
}

// GetResourceVersion is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetResourceVersion() *mockkubernetesObject_GetResourceVersion_Call[T] {
	return &mockkubernetesObject_GetResourceVersion_Call[T]{Call: _e.mock.On("GetResourceVersion")}
}

func (_c *mockkubernetesObject_GetResourceVersion_Call[T]) Run(run func()) *mockkubernetesObject_GetResourceVersion_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetResourceVersion_Call[T]) Return(s string) *mockkubernetesObject_GetResourceVersion_Call[T] {
	_c.Call.Return(s)
	return _c
}

func (_c *mockkubernetesObject_GetResourceVersion_Call[T]) RunAndReturn(run func() string) *mockkubernetesObject_GetResourceVersion_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetSelfLink provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetSelfLink() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// mockkubernetesObject_GetSelfLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSelfLink'
type mockkubernetesObject_GetSelfLink_Call[T client.Object] struct {
	*mock.Call
}

// GetSelfLink is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetSelfLink() *mockkubernetesObject_GetSelfLink_Call[T] {
	return &mockkubernetesObject_GetSelfLink_Call[T]{Call: _e.mock.On("GetSelfLink")}
}

func (_c *mockkubernetesObject_GetSelfLink_Call[T]) Run(run func()) *mockkubernetesObject_GetSelfLink_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetSelfLink_Call[T]) Return(s string) *mockkubernetesObject_GetSelfLink_Call[T] {
	_c.Call.Return(s)
	return _c
}

func (_c *mockkubernetesObject_GetSelfLink_Call[T]) RunAndReturn(run func() string) *mockkubernetesObject_GetSelfLink_Call[T] {
	_c.Call.Return(run)
	return _c
}

// GetUID provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) GetUID() types.UID {
	ret := _mock.Called()

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

	var r0 types.UID
	if returnFunc, ok := ret.Get(0).(func() types.UID); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(types.UID)
	}
	return r0
}

// mockkubernetesObject_GetUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUID'
type mockkubernetesObject_GetUID_Call[T client.Object] struct {
	*mock.Call
}

// GetUID is a helper method to define mock.On call
func (_e *mockkubernetesObject_Expecter[T]) GetUID() *mockkubernetesObject_GetUID_Call[T] {
	return &mockkubernetesObject_GetUID_Call[T]{Call: _e.mock.On("GetUID")}
}

func (_c *mockkubernetesObject_GetUID_Call[T]) Run(run func()) *mockkubernetesObject_GetUID_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockkubernetesObject_GetUID_Call[T]) Return(uID types.UID) *mockkubernetesObject_GetUID_Call[T] {
	_c.Call.Return(uID)
	return _c
}

func (_c *mockkubernetesObject_GetUID_Call[T]) RunAndReturn(run func() types.UID) *mockkubernetesObject_GetUID_Call[T] {
	_c.Call.Return(run)
	return _c
}

// SetAnnotations provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetAnnotations(annotations map[string]string) {
	_mock.Called(annotations)
	return
}

// mockkubernetesObject_SetAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAnnotations'
type mockkubernetesObject_SetAnnotations_Call[T client.Object] struct {
	*mock.Call
}

// SetAnnotations is a helper method to define mock.On call
//   - annotations map[string]string
func (_e *mockkubernetesObject_Expecter[T]) SetAnnotations(annotations interface{}) *mockkubernetesObject_SetAnnotations_Call[T] {
	return &mockkubernetesObject_SetAnnotations_Call[T]{Call: _e.mock.On("SetAnnotations", annotations)}
}

func (_c *mockkubernetesObject_SetAnnotations_Call[T]) Run(run func(annotations map[string]string)) *mockkubernetesObject_SetAnnotations_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 map[string]string
		if args[0] != nil {
			arg0 = args[0].(map[string]string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetAnnotations_Call[T]) Return() *mockkubernetesObject_SetAnnotations_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetAnnotations_Call[T]) RunAndReturn(run func(annotations map[string]string)) *mockkubernetesObject_SetAnnotations_Call[T] {
	_c.Run(run)
	return _c
}

// SetCreationTimestamp provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetCreationTimestamp(timestamp v1.Time) {
	_mock.Called(timestamp)
	return
}

// mockkubernetesObject_SetCreationTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreationTimestamp'
type mockkubernetesObject_SetCreationTimestamp_Call[T client.Object] struct {
	*mock.Call
}

// SetCreationTimestamp is a helper method to define mock.On call
//   - timestamp v1.Time
func (_e *mockkubernetesObject_Expecter[T]) SetCreationTimestamp(timestamp interface{}) *mockkubernetesObject_SetCreationTimestamp_Call[T] {
	return &mockkubernetesObject_SetCreationTimestamp_Call[T]{Call: _e.mock.On("SetCreationTimestamp", timestamp)}
}

func (_c *mockkubernetesObject_SetCreationTimestamp_Call[T]) Run(run func(timestamp v1.Time)) *mockkubernetesObject_SetCreationTimestamp_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 v1.Time
		if args[0] != nil {
			arg0 = args[0].(v1.Time)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetCreationTimestamp_Call[T]) Return() *mockkubernetesObject_SetCreationTimestamp_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetCreationTimestamp_Call[T]) RunAndReturn(run func(timestamp v1.Time)) *mockkubernetesObject_SetCreationTimestamp_Call[T] {
	_c.Run(run)
	return _c
}

// SetDeletionGracePeriodSeconds provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetDeletionGracePeriodSeconds(n *int64) {
	_mock.Called(n)
	return
}

// mockkubernetesObject_SetDeletionGracePeriodSeconds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeletionGracePeriodSeconds'
type mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T client.Object] struct {
	*mock.Call
}

// SetDeletionGracePeriodSeconds is a helper method to define mock.On call
//   - n *int64
func (_e *mockkubernetesObject_Expecter[T]) SetDeletionGracePeriodSeconds(n interface{}) *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T] {
	return &mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T]{Call: _e.mock.On("SetDeletionGracePeriodSeconds", n)}
}

func (_c *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T]) Run(run func(n *int64)) *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *int64
		if args[0] != nil {
			arg0 = args[0].(*int64)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T]) Return() *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T]) RunAndReturn(run func(n *int64)) *mockkubernetesObject_SetDeletionGracePeriodSeconds_Call[T] {
	_c.Run(run)
	return _c
}

// SetDeletionTimestamp provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetDeletionTimestamp(timestamp *v1.Time) {
	_mock.Called(timestamp)
	return
}

// mockkubernetesObject_SetDeletionTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeletionTimestamp'
type mockkubernetesObject_SetDeletionTimestamp_Call[T client.Object] struct {
	*mock.Call
}

// SetDeletionTimestamp is a helper method to define mock.On call
//   - timestamp *v1.Time
func (_e *mockkubernetesObject_Expecter[T]) SetDeletionTimestamp(timestamp interface{}) *mockkubernetesObject_SetDeletionTimestamp_Call[T] {
	return &mockkubernetesObject_SetDeletionTimestamp_Call[T]{Call: _e.mock.On("SetDeletionTimestamp", timestamp)}
}

func (_c *mockkubernetesObject_SetDeletionTimestamp_Call[T]) Run(run func(timestamp *v1.Time)) *mockkubernetesObject_SetDeletionTimestamp_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *v1.Time
		if args[0] != nil {
			arg0 = args[0].(*v1.Time)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetDeletionTimestamp_Call[T]) Return() *mockkubernetesObject_SetDeletionTimestamp_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetDeletionTimestamp_Call[T]) RunAndReturn(run func(timestamp *v1.Time)) *mockkubernetesObject_SetDeletionTimestamp_Call[T] {
	_c.Run(run)
	return _c
}

// SetFinalizers provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetFinalizers(finalizers []string) {
	_mock.Called(finalizers)
	return
}

// mockkubernetesObject_SetFinalizers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFinalizers'
type mockkubernetesObject_SetFinalizers_Call[T client.Object] struct {
	*mock.Call
}

// SetFinalizers is a helper method to define mock.On call
//   - finalizers []string
func (_e *mockkubernetesObject_Expecter[T]) SetFinalizers(finalizers interface{}) *mockkubernetesObject_SetFinalizers_Call[T] {
	return &mockkubernetesObject_SetFinalizers_Call[T]{Call: _e.mock.On("SetFinalizers", finalizers)}
}

func (_c *mockkubernetesObject_SetFinalizers_Call[T]) Run(run func(finalizers []string)) *mockkubernetesObject_SetFinalizers_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []string
		if args[0] != nil {
			arg0 = args[0].([]string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetFinalizers_Call[T]) Return() *mockkubernetesObject_SetFinalizers_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetFinalizers_Call[T]) RunAndReturn(run func(finalizers []string)) *mockkubernetesObject_SetFinalizers_Call[T] {
	_c.Run(run)
	return _c
}

// SetGenerateName provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetGenerateName(name string) {
	_mock.Called(name)
	return
}

// mockkubernetesObject_SetGenerateName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetGenerateName'
type mockkubernetesObject_SetGenerateName_Call[T client.Object] struct {
	*mock.Call
}

// SetGenerateName is a helper method to define mock.On call
//   - name string
func (_e *mockkubernetesObject_Expecter[T]) SetGenerateName(name interface{}) *mockkubernetesObject_SetGenerateName_Call[T] {
	return &mockkubernetesObject_SetGenerateName_Call[T]{Call: _e.mock.On("SetGenerateName", name)}
}

func (_c *mockkubernetesObject_SetGenerateName_Call[T]) Run(run func(name string)) *mockkubernetesObject_SetGenerateName_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetGenerateName_Call[T]) Return() *mockkubernetesObject_SetGenerateName_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetGenerateName_Call[T]) RunAndReturn(run func(name string)) *mockkubernetesObject_SetGenerateName_Call[T] {
	_c.Run(run)
	return _c
}

// SetGeneration provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetGeneration(generation int64) {
	_mock.Called(generation)
	return
}

// mockkubernetesObject_SetGeneration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetGeneration'
type mockkubernetesObject_SetGeneration_Call[T client.Object] struct {
	*mock.Call
}

// SetGeneration is a helper method to define mock.On call
//   - generation int64
func (_e *mockkubernetesObject_Expecter[T]) SetGeneration(generation interface{}) *mockkubernetesObject_SetGeneration_Call[T] {
	return &mockkubernetesObject_SetGeneration_Call[T]{Call: _e.mock.On("SetGeneration", generation)}
}

func (_c *mockkubernetesObject_SetGeneration_Call[T]) Run(run func(generation int64)) *mockkubernetesObject_SetGeneration_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetGeneration_Call[T]) Return() *mockkubernetesObject_SetGeneration_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetGeneration_Call[T]) RunAndReturn(run func(generation int64)) *mockkubernetesObject_SetGeneration_Call[T] {
	_c.Run(run)
	return _c
}

// SetLabels provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetLabels(labels map[string]string) {
	_mock.Called(labels)
	return
}

// mockkubernetesObject_SetLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabels'
type mockkubernetesObject_SetLabels_Call[T client.Object] struct {
	*mock.Call
}

// SetLabels is a helper method to define mock.On call
//   - labels map[string]string
func (_e *mockkubernetesObject_Expecter[T]) SetLabels(labels interface{}) *mockkubernetesObject_SetLabels_Call[T] {
	return &mockkubernetesObject_SetLabels_Call[T]{Call: _e.mock.On("SetLabels", labels)}
}

func (_c *mockkubernetesObject_SetLabels_Call[T]) Run(run func(labels map[string]string)) *mockkubernetesObject_SetLabels_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 map[string]string
		if args[0] != nil {
			arg0 = args[0].(map[string]string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetLabels_Call[T]) Return() *mockkubernetesObject_SetLabels_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetLabels_Call[T]) RunAndReturn(run func(labels map[string]string)) *mockkubernetesObject_SetLabels_Call[T] {
	_c.Run(run)
	return _c
}

// SetManagedFields provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetManagedFields(managedFields []v1.ManagedFieldsEntry) {
	_mock.Called(managedFields)
	return
}

// mockkubernetesObject_SetManagedFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetManagedFields'
type mockkubernetesObject_SetManagedFields_Call[T client.Object] struct {
	*mock.Call
}

// SetManagedFields is a helper method to define mock.On call
//   - managedFields []v1.ManagedFieldsEntry
func (_e *mockkubernetesObject_Expecter[T]) SetManagedFields(managedFields interface{}) *mockkubernetesObject_SetManagedFields_Call[T] {
	return &mockkubernetesObject_SetManagedFields_Call[T]{Call: _e.mock.On("SetManagedFields", managedFields)}
}

func (_c *mockkubernetesObject_SetManagedFields_Call[T]) Run(run func(managedFields []v1.ManagedFieldsEntry)) *mockkubernetesObject_SetManagedFields_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []v1.ManagedFieldsEntry
		if args[0] != nil {
			arg0 = args[0].([]v1.ManagedFieldsEntry)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetManagedFields_Call[T]) Return() *mockkubernetesObject_SetManagedFields_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetManagedFields_Call[T]) RunAndReturn(run func(managedFields []v1.ManagedFieldsEntry)) *mockkubernetesObject_SetManagedFields_Call[T] {
	_c.Run(run)
	return _c
}

// SetName provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetName(name string) {
	_mock.Called(name)
	return
}

// mockkubernetesObject_SetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetName'
type mockkubernetesObject_SetName_Call[T client.Object] struct {
	*mock.Call
}

// SetName is a helper method to define mock.On call
//   - name string
func (_e *mockkubernetesObject_Expecter[T]) SetName(name interface{}) *mockkubernetesObject_SetName_Call[T] {
	return &mockkubernetesObject_SetName_Call[T]{Call: _e.mock.On("SetName", name)}
}

func (_c *mockkubernetesObject_SetName_Call[T]) Run(run func(name string)) *mockkubernetesObject_SetName_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetName_Call[T]) Return() *mockkubernetesObject_SetName_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetName_Call[T]) RunAndReturn(run func(name string)) *mockkubernetesObject_SetName_Call[T] {
	_c.Run(run)
	return _c
}

// SetNamespace provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetNamespace(namespace string) {
	_mock.Called(namespace)
	return
}

// mockkubernetesObject_SetNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNamespace'
type mockkubernetesObject_SetNamespace_Call[T client.Object] struct {
	*mock.Call
}

// SetNamespace is a helper method to define mock.On call
//   - namespace string
func (_e *mockkubernetesObject_Expecter[T]) SetNamespace(namespace interface{}) *mockkubernetesObject_SetNamespace_Call[T] {
	return &mockkubernetesObject_SetNamespace_Call[T]{Call: _e.mock.On("SetNamespace", namespace)}
}

func (_c *mockkubernetesObject_SetNamespace_Call[T]) Run(run func(namespace string)) *mockkubernetesObject_SetNamespace_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetNamespace_Call[T]) Return() *mockkubernetesObject_SetNamespace_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetNamespace_Call[T]) RunAndReturn(run func(namespace string)) *mockkubernetesObject_SetNamespace_Call[T] {
	_c.Run(run)
	return _c
}

// SetOwnerReferences provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetOwnerReferences(ownerReferences []v1.OwnerReference) {
	_mock.Called(ownerReferences)
	return
}

// mockkubernetesObject_SetOwnerReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOwnerReferences'
type mockkubernetesObject_SetOwnerReferences_Call[T client.Object] struct {
	*mock.Call
}

// SetOwnerReferences is a helper method to define mock.On call
//   - ownerReferences []v1.OwnerReference
func (_e *mockkubernetesObject_Expecter[T]) SetOwnerReferences(ownerReferences interface{}) *mockkubernetesObject_SetOwnerReferences_Call[T] {
	return &mockkubernetesObject_SetOwnerReferences_Call[T]{Call: _e.mock.On("SetOwnerReferences", ownerReferences)}
}

func (_c *mockkubernetesObject_SetOwnerReferences_Call[T]) Run(run func(ownerReferences []v1.OwnerReference)) *mockkubernetesObject_SetOwnerReferences_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []v1.OwnerReference
		if args[0] != nil {
			arg0 = args[0].([]v1.OwnerReference)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetOwnerReferences_Call[T]) Return() *mockkubernetesObject_SetOwnerReferences_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetOwnerReferences_Call[T]) RunAndReturn(run func(ownerReferences []v1.OwnerReference)) *mockkubernetesObject_SetOwnerReferences_Call[T] {
	_c.Run(run)
	return _c
}

// SetResourceVersion provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetResourceVersion(version string) {
	_mock.Called(version)
	return
}

// mockkubernetesObject_SetResourceVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResourceVersion'
type mockkubernetesObject_SetResourceVersion_Call[T client.Object] struct {
	*mock.Call
}

// SetResourceVersion is a helper method to define mock.On call
//   - version string
func (_e *mockkubernetesObject_Expecter[T]) SetResourceVersion(version interface{}) *mockkubernetesObject_SetResourceVersion_Call[T] {
	return &mockkubernetesObject_SetResourceVersion_Call[T]{Call: _e.mock.On("SetResourceVersion", version)}
}

func (_c *mockkubernetesObject_SetResourceVersion_Call[T]) Run(run func(version string)) *mockkubernetesObject_SetResourceVersion_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetResourceVersion_Call[T]) Return() *mockkubernetesObject_SetResourceVersion_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetResourceVersion_Call[T]) RunAndReturn(run func(version string)) *mockkubernetesObject_SetResourceVersion_Call[T] {
	_c.Run(run)
	return _c
}

// SetSelfLink provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetSelfLink(selfLink string) {
	_mock.Called(selfLink)
	return
}

// mockkubernetesObject_SetSelfLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSelfLink'
type mockkubernetesObject_SetSelfLink_Call[T client.Object] struct {
	*mock.Call
}

// SetSelfLink is a helper method to define mock.On call
//   - selfLink string
func (_e *mockkubernetesObject_Expecter[T]) SetSelfLink(selfLink interface{}) *mockkubernetesObject_SetSelfLink_Call[T] {
	return &mockkubernetesObject_SetSelfLink_Call[T]{Call: _e.mock.On("SetSelfLink", selfLink)}
}

func (_c *mockkubernetesObject_SetSelfLink_Call[T]) Run(run func(selfLink string)) *mockkubernetesObject_SetSelfLink_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetSelfLink_Call[T]) Return() *mockkubernetesObject_SetSelfLink_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetSelfLink_Call[T]) RunAndReturn(run func(selfLink string)) *mockkubernetesObject_SetSelfLink_Call[T] {
	_c.Run(run)
	return _c
}

// SetUID provides a mock function for the type mockkubernetesObject
func (_mock *mockkubernetesObject[T]) SetUID(uid types.UID) {
	_mock.Called(uid)
	return
}

// mockkubernetesObject_SetUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUID'
type mockkubernetesObject_SetUID_Call[T client.Object] struct {
	*mock.Call
}

// SetUID is a helper method to define mock.On call
//   - uid types.UID
func (_e *mockkubernetesObject_Expecter[T]) SetUID(uid interface{}) *mockkubernetesObject_SetUID_Call[T] {
	return &mockkubernetesObject_SetUID_Call[T]{Call: _e.mock.On("SetUID", uid)}
}

func (_c *mockkubernetesObject_SetUID_Call[T]) Run(run func(uid types.UID)) *mockkubernetesObject_SetUID_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 types.UID
		if args[0] != nil {
			arg0 = args[0].(types.UID)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockkubernetesObject_SetUID_Call[T]) Return() *mockkubernetesObject_SetUID_Call[T] {
	_c.Call.Return()
	return _c
}

func (_c *mockkubernetesObject_SetUID_Call[T]) RunAndReturn(run func(uid types.UID)) *mockkubernetesObject_SetUID_Call[T] {
	_c.Run(run)
	return _c
}

// newMockpatcher creates a new instance of mockpatcher. 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 newMockpatcher(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockpatcher {
	mock := &mockpatcher{}
	mock.Mock.Test(t)

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

	return mock
}

// mockpatcher is an autogenerated mock type for the patcher type
type mockpatcher struct {
	mock.Mock
}

type mockpatcher_Expecter struct {
	mock *mock.Mock
}

func (_m *mockpatcher) EXPECT() *mockpatcher_Expecter {
	return &mockpatcher_Expecter{mock: &_m.Mock}
}

// Patch provides a mock function for the type mockpatcher
func (_mock *mockpatcher) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, obj, patch, opts)
	} else {
		tmpRet = _mock.Called(ctx, obj, patch)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.Object, client.Patch, ...client.PatchOption) error); ok {
		r0 = returnFunc(ctx, obj, patch, opts...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Patch is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - patch client.Patch
//   - opts ...client.PatchOption
func (_e *mockpatcher_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *mockpatcher_Patch_Call {
	return &mockpatcher_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *mockpatcher_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption)) *mockpatcher_Patch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.Object
		if args[1] != nil {
			arg1 = args[1].(client.Object)
		}
		var arg2 client.Patch
		if args[2] != nil {
			arg2 = args[2].(client.Patch)
		}
		var arg3 []client.PatchOption
		var variadicArgs []client.PatchOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.PatchOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *mockpatcher_Patch_Call) Return(err error) *mockpatcher_Patch_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockpatcher_Patch_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error) *mockpatcher_Patch_Call {
	_c.Call.Return(run)
	return _c
}

// newMocksubResourcePatcher creates a new instance of mocksubResourcePatcher. 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 newMocksubResourcePatcher(t interface {
	mock.TestingT
	Cleanup(func())
}) *mocksubResourcePatcher {
	mock := &mocksubResourcePatcher{}
	mock.Mock.Test(t)

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

	return mock
}

// mocksubResourcePatcher is an autogenerated mock type for the subResourcePatcher type
type mocksubResourcePatcher struct {
	mock.Mock
}

type mocksubResourcePatcher_Expecter struct {
	mock *mock.Mock
}

func (_m *mocksubResourcePatcher) EXPECT() *mocksubResourcePatcher_Expecter {
	return &mocksubResourcePatcher_Expecter{mock: &_m.Mock}
}

// Patch provides a mock function for the type mocksubResourcePatcher
func (_mock *mocksubResourcePatcher) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, obj, patch, opts)
	} else {
		tmpRet = _mock.Called(ctx, obj, patch)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.Object, client.Patch, ...client.SubResourcePatchOption) error); ok {
		r0 = returnFunc(ctx, obj, patch, opts...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Patch is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - patch client.Patch
//   - opts ...client.SubResourcePatchOption
func (_e *mocksubResourcePatcher_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *mocksubResourcePatcher_Patch_Call {
	return &mocksubResourcePatcher_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *mocksubResourcePatcher_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption)) *mocksubResourcePatcher_Patch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.Object
		if args[1] != nil {
			arg1 = args[1].(client.Object)
		}
		var arg2 client.Patch
		if args[2] != nil {
			arg2 = args[2].(client.Patch)
		}
		var arg3 []client.SubResourcePatchOption
		var variadicArgs []client.SubResourcePatchOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.SubResourcePatchOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *mocksubResourcePatcher_Patch_Call) Return(err error) *mocksubResourcePatcher_Patch_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mocksubResourcePatcher_Patch_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error) *mocksubResourcePatcher_Patch_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSecretResolver creates a new instance of MockSecretResolver. 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 NewMockSecretResolver(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSecretResolver {
	mock := &MockSecretResolver{}
	mock.Mock.Test(t)

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

	return mock
}

// MockSecretResolver is an autogenerated mock type for the SecretResolver type
type MockSecretResolver struct {
	mock.Mock
}

type MockSecretResolver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSecretResolver) EXPECT() *MockSecretResolver_Expecter {
	return &MockSecretResolver_Expecter{mock: &_m.Mock}
}

// GetActionsService provides a mock function for the type MockSecretResolver
func (_mock *MockSecretResolver) GetActionsService(ctx context.Context, obj object.ActionsGitHubObject) (multiclient.Client, error) {
	ret := _mock.Called(ctx, obj)

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

	var r0 multiclient.Client
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ActionsGitHubObject) (multiclient.Client, error)); ok {
		return returnFunc(ctx, obj)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ActionsGitHubObject) multiclient.Client); ok {
		r0 = returnFunc(ctx, obj)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(multiclient.Client)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, object.ActionsGitHubObject) error); ok {
		r1 = returnFunc(ctx, obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetActionsService is a helper method to define mock.On call
//   - ctx context.Context
//   - obj object.ActionsGitHubObject
func (_e *MockSecretResolver_Expecter) GetActionsService(ctx interface{}, obj interface{}) *MockSecretResolver_GetActionsService_Call {
	return &MockSecretResolver_GetActionsService_Call{Call: _e.mock.On("GetActionsService", ctx, obj)}
}

func (_c *MockSecretResolver_GetActionsService_Call) Run(run func(ctx context.Context, obj object.ActionsGitHubObject)) *MockSecretResolver_GetActionsService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 object.ActionsGitHubObject
		if args[1] != nil {
			arg1 = args[1].(object.ActionsGitHubObject)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockSecretResolver_GetActionsService_Call) Return(client1 multiclient.Client, err error) *MockSecretResolver_GetActionsService_Call {
	_c.Call.Return(client1, err)
	return _c
}

func (_c *MockSecretResolver_GetActionsService_Call) RunAndReturn(run func(ctx context.Context, obj object.ActionsGitHubObject) (multiclient.Client, error)) *MockSecretResolver_GetActionsService_Call {
	_c.Call.Return(run)
	return _c
}

// GetAppConfig provides a mock function for the type MockSecretResolver
func (_mock *MockSecretResolver) GetAppConfig(ctx context.Context, obj object.ActionsGitHubObject) (*appconfig.AppConfig, error) {
	ret := _mock.Called(ctx, obj)

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

	var r0 *appconfig.AppConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ActionsGitHubObject) (*appconfig.AppConfig, error)); ok {
		return returnFunc(ctx, obj)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ActionsGitHubObject) *appconfig.AppConfig); ok {
		r0 = returnFunc(ctx, obj)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*appconfig.AppConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, object.ActionsGitHubObject) error); ok {
		r1 = returnFunc(ctx, obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetAppConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - obj object.ActionsGitHubObject
func (_e *MockSecretResolver_Expecter) GetAppConfig(ctx interface{}, obj interface{}) *MockSecretResolver_GetAppConfig_Call {
	return &MockSecretResolver_GetAppConfig_Call{Call: _e.mock.On("GetAppConfig", ctx, obj)}
}

func (_c *MockSecretResolver_GetAppConfig_Call) Run(run func(ctx context.Context, obj object.ActionsGitHubObject)) *MockSecretResolver_GetAppConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 object.ActionsGitHubObject
		if args[1] != nil {
			arg1 = args[1].(object.ActionsGitHubObject)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockSecretResolver_GetAppConfig_Call) Return(appConfig *appconfig.AppConfig, err error) *MockSecretResolver_GetAppConfig_Call {
	_c.Call.Return(appConfig, err)
	return _c
}

func (_c *MockSecretResolver_GetAppConfig_Call) RunAndReturn(run func(ctx context.Context, obj object.ActionsGitHubObject) (*appconfig.AppConfig, error)) *MockSecretResolver_GetAppConfig_Call {
	_c.Call.Return(run)
	return _c
}