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

package mocks

import (
	"context"

	mock "github.com/stretchr/testify/mock"
	"k8s.io/apimachinery/pkg/api/meta"
	"k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/apimachinery/pkg/watch"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

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

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

	return mock
}

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

type SubResourceUpdateAndPatchOption_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceUpdateAndPatchOption) EXPECT() *SubResourceUpdateAndPatchOption_Expecter {
	return &SubResourceUpdateAndPatchOption_Expecter{mock: &_m.Mock}
}

// ApplyToSubResourcePatch provides a mock function for the type SubResourceUpdateAndPatchOption
func (_mock *SubResourceUpdateAndPatchOption) ApplyToSubResourcePatch(subResourcePatchOptions *client.SubResourcePatchOptions) {
	_mock.Called(subResourcePatchOptions)
	return
}

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

// ApplyToSubResourcePatch is a helper method to define mock.On call
//   - subResourcePatchOptions *client.SubResourcePatchOptions
func (_e *SubResourceUpdateAndPatchOption_Expecter) ApplyToSubResourcePatch(subResourcePatchOptions interface{}) *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call {
	return &SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call{Call: _e.mock.On("ApplyToSubResourcePatch", subResourcePatchOptions)}
}

func (_c *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call) Run(run func(subResourcePatchOptions *client.SubResourcePatchOptions)) *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.SubResourcePatchOptions
		if args[0] != nil {
			arg0 = args[0].(*client.SubResourcePatchOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call) Return() *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call {
	_c.Call.Return()
	return _c
}

func (_c *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call) RunAndReturn(run func(subResourcePatchOptions *client.SubResourcePatchOptions)) *SubResourceUpdateAndPatchOption_ApplyToSubResourcePatch_Call {
	_c.Run(run)
	return _c
}

// ApplyToSubResourceUpdate provides a mock function for the type SubResourceUpdateAndPatchOption
func (_mock *SubResourceUpdateAndPatchOption) ApplyToSubResourceUpdate(subResourceUpdateOptions *client.SubResourceUpdateOptions) {
	_mock.Called(subResourceUpdateOptions)
	return
}

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

// ApplyToSubResourceUpdate is a helper method to define mock.On call
//   - subResourceUpdateOptions *client.SubResourceUpdateOptions
func (_e *SubResourceUpdateAndPatchOption_Expecter) ApplyToSubResourceUpdate(subResourceUpdateOptions interface{}) *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call {
	return &SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call{Call: _e.mock.On("ApplyToSubResourceUpdate", subResourceUpdateOptions)}
}

func (_c *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call) Run(run func(subResourceUpdateOptions *client.SubResourceUpdateOptions)) *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.SubResourceUpdateOptions
		if args[0] != nil {
			arg0 = args[0].(*client.SubResourceUpdateOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call) Return() *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call {
	_c.Call.Return()
	return _c
}

func (_c *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call) RunAndReturn(run func(subResourceUpdateOptions *client.SubResourceUpdateOptions)) *SubResourceUpdateAndPatchOption_ApplyToSubResourceUpdate_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type Patch_Expecter struct {
	mock *mock.Mock
}

func (_m *Patch) EXPECT() *Patch_Expecter {
	return &Patch_Expecter{mock: &_m.Mock}
}

// Data provides a mock function for the type Patch
func (_mock *Patch) Data(obj client.Object) ([]byte, error) {
	ret := _mock.Called(obj)

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

	var r0 []byte
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.Object) ([]byte, error)); ok {
		return returnFunc(obj)
	}
	if returnFunc, ok := ret.Get(0).(func(client.Object) []byte); ok {
		r0 = returnFunc(obj)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.Object) error); ok {
		r1 = returnFunc(obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Data is a helper method to define mock.On call
//   - obj client.Object
func (_e *Patch_Expecter) Data(obj interface{}) *Patch_Data_Call {
	return &Patch_Data_Call{Call: _e.mock.On("Data", obj)}
}

func (_c *Patch_Data_Call) Run(run func(obj client.Object)) *Patch_Data_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.Object
		if args[0] != nil {
			arg0 = args[0].(client.Object)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Patch_Data_Call) Return(bytes []byte, err error) *Patch_Data_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *Patch_Data_Call) RunAndReturn(run func(obj client.Object) ([]byte, error)) *Patch_Data_Call {
	_c.Call.Return(run)
	return _c
}

// Type provides a mock function for the type Patch
func (_mock *Patch) Type() types.PatchType {
	ret := _mock.Called()

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

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

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

// Type is a helper method to define mock.On call
func (_e *Patch_Expecter) Type() *Patch_Type_Call {
	return &Patch_Type_Call{Call: _e.mock.On("Type")}
}

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

func (_c *Patch_Type_Call) Return(patchType types.PatchType) *Patch_Type_Call {
	_c.Call.Return(patchType)
	return _c
}

func (_c *Patch_Type_Call) RunAndReturn(run func() types.PatchType) *Patch_Type_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type Reader_Expecter struct {
	mock *mock.Mock
}

func (_m *Reader) EXPECT() *Reader_Expecter {
	return &Reader_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - key client.ObjectKey
//   - obj client.Object
//   - opts ...client.GetOption
func (_e *Reader_Expecter) Get(ctx interface{}, key interface{}, obj interface{}, opts ...interface{}) *Reader_Get_Call {
	return &Reader_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{ctx, key, obj}, opts...)...)}
}

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

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

func (_c *Reader_Get_Call) RunAndReturn(run func(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error) *Reader_Get_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type Reader
func (_mock *Reader) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, list, opts)
	} else {
		tmpRet = _mock.Called(ctx, list)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) error); ok {
		r0 = returnFunc(ctx, list, opts...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - list client.ObjectList
//   - opts ...client.ListOption
func (_e *Reader_Expecter) List(ctx interface{}, list interface{}, opts ...interface{}) *Reader_List_Call {
	return &Reader_List_Call{Call: _e.mock.On("List",
		append([]interface{}{ctx, list}, opts...)...)}
}

func (_c *Reader_List_Call) Run(run func(ctx context.Context, list client.ObjectList, opts ...client.ListOption)) *Reader_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.ObjectList
		if args[1] != nil {
			arg1 = args[1].(client.ObjectList)
		}
		var arg2 []client.ListOption
		var variadicArgs []client.ListOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ListOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Reader_List_Call) RunAndReturn(run func(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error) *Reader_List_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type Writer_Expecter struct {
	mock *mock.Mock
}

func (_m *Writer) EXPECT() *Writer_Expecter {
	return &Writer_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

func (_c *Writer_Create_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.CreateOption)) *Writer_Create_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.CreateOption
		var variadicArgs []client.CreateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.CreateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Writer_Create_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error) *Writer_Create_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *Writer_Delete_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.DeleteOption)) *Writer_Delete_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.DeleteOption
		var variadicArgs []client.DeleteOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.DeleteOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Writer_Delete_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error) *Writer_Delete_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *Writer_DeleteAllOf_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption)) *Writer_DeleteAllOf_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.DeleteAllOfOption
		var variadicArgs []client.DeleteAllOfOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.DeleteAllOfOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Writer_DeleteAllOf_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error) *Writer_DeleteAllOf_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type Writer
func (_mock *Writer) 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
}

// Writer_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type Writer_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 *Writer_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *Writer_Patch_Call {
	return &Writer_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *Writer_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption)) *Writer_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 *Writer_Patch_Call) Return(err error) *Writer_Patch_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

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

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

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

func (_c *Writer_Update_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.UpdateOption)) *Writer_Update_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.UpdateOption
		var variadicArgs []client.UpdateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.UpdateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Writer_Update_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error) *Writer_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type StatusClient_Expecter struct {
	mock *mock.Mock
}

func (_m *StatusClient) EXPECT() *StatusClient_Expecter {
	return &StatusClient_Expecter{mock: &_m.Mock}
}

// Status provides a mock function for the type StatusClient
func (_mock *StatusClient) Status() client.SubResourceWriter {
	ret := _mock.Called()

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

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

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

// Status is a helper method to define mock.On call
func (_e *StatusClient_Expecter) Status() *StatusClient_Status_Call {
	return &StatusClient_Status_Call{Call: _e.mock.On("Status")}
}

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

func (_c *StatusClient_Status_Call) Return(subResourceWriter client.SubResourceWriter) *StatusClient_Status_Call {
	_c.Call.Return(subResourceWriter)
	return _c
}

func (_c *StatusClient_Status_Call) RunAndReturn(run func() client.SubResourceWriter) *StatusClient_Status_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceClientConstructor_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceClientConstructor) EXPECT() *SubResourceClientConstructor_Expecter {
	return &SubResourceClientConstructor_Expecter{mock: &_m.Mock}
}

// SubResource provides a mock function for the type SubResourceClientConstructor
func (_mock *SubResourceClientConstructor) SubResource(subResource string) client.SubResourceClient {
	ret := _mock.Called(subResource)

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

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

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

// SubResource is a helper method to define mock.On call
//   - subResource string
func (_e *SubResourceClientConstructor_Expecter) SubResource(subResource interface{}) *SubResourceClientConstructor_SubResource_Call {
	return &SubResourceClientConstructor_SubResource_Call{Call: _e.mock.On("SubResource", subResource)}
}

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

func (_c *SubResourceClientConstructor_SubResource_Call) Return(subResourceClient client.SubResourceClient) *SubResourceClientConstructor_SubResource_Call {
	_c.Call.Return(subResourceClient)
	return _c
}

func (_c *SubResourceClientConstructor_SubResource_Call) RunAndReturn(run func(subResource string) client.SubResourceClient) *SubResourceClientConstructor_SubResource_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type StatusWriter_Expecter struct {
	mock *mock.Mock
}

func (_m *StatusWriter) EXPECT() *StatusWriter_Expecter {
	return &StatusWriter_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - subResource client.Object
//   - opts ...client.SubResourceCreateOption
func (_e *StatusWriter_Expecter) Create(ctx interface{}, obj interface{}, subResource interface{}, opts ...interface{}) *StatusWriter_Create_Call {
	return &StatusWriter_Create_Call{Call: _e.mock.On("Create",
		append([]interface{}{ctx, obj, subResource}, opts...)...)}
}

func (_c *StatusWriter_Create_Call) Run(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption)) *StatusWriter_Create_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.Object
		if args[2] != nil {
			arg2 = args[2].(client.Object)
		}
		var arg3 []client.SubResourceCreateOption
		var variadicArgs []client.SubResourceCreateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.SubResourceCreateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *StatusWriter_Create_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption) error) *StatusWriter_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type StatusWriter
func (_mock *StatusWriter) 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
}

// StatusWriter_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type StatusWriter_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 *StatusWriter_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *StatusWriter_Patch_Call {
	return &StatusWriter_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *StatusWriter_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption)) *StatusWriter_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 *StatusWriter_Patch_Call) Return(err error) *StatusWriter_Patch_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

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

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

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

func (_c *StatusWriter_Update_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption)) *StatusWriter_Update_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.SubResourceUpdateOption
		var variadicArgs []client.SubResourceUpdateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.SubResourceUpdateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *StatusWriter_Update_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error) *StatusWriter_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceReader_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceReader) EXPECT() *SubResourceReader_Expecter {
	return &SubResourceReader_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - subResource client.Object
//   - opts ...client.SubResourceGetOption
func (_e *SubResourceReader_Expecter) Get(ctx interface{}, obj interface{}, subResource interface{}, opts ...interface{}) *SubResourceReader_Get_Call {
	return &SubResourceReader_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{ctx, obj, subResource}, opts...)...)}
}

func (_c *SubResourceReader_Get_Call) Run(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceGetOption)) *SubResourceReader_Get_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.Object
		if args[2] != nil {
			arg2 = args[2].(client.Object)
		}
		var arg3 []client.SubResourceGetOption
		var variadicArgs []client.SubResourceGetOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.SubResourceGetOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *SubResourceReader_Get_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceGetOption) error) *SubResourceReader_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceWriter_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceWriter) EXPECT() *SubResourceWriter_Expecter {
	return &SubResourceWriter_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - subResource client.Object
//   - opts ...client.SubResourceCreateOption
func (_e *SubResourceWriter_Expecter) Create(ctx interface{}, obj interface{}, subResource interface{}, opts ...interface{}) *SubResourceWriter_Create_Call {
	return &SubResourceWriter_Create_Call{Call: _e.mock.On("Create",
		append([]interface{}{ctx, obj, subResource}, opts...)...)}
}

func (_c *SubResourceWriter_Create_Call) Run(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption)) *SubResourceWriter_Create_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.Object
		if args[2] != nil {
			arg2 = args[2].(client.Object)
		}
		var arg3 []client.SubResourceCreateOption
		var variadicArgs []client.SubResourceCreateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.SubResourceCreateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *SubResourceWriter_Create_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption) error) *SubResourceWriter_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type SubResourceWriter
func (_mock *SubResourceWriter) 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
}

// SubResourceWriter_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type SubResourceWriter_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 *SubResourceWriter_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *SubResourceWriter_Patch_Call {
	return &SubResourceWriter_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *SubResourceWriter_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption)) *SubResourceWriter_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 *SubResourceWriter_Patch_Call) Return(err error) *SubResourceWriter_Patch_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

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

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

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

func (_c *SubResourceWriter_Update_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption)) *SubResourceWriter_Update_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.SubResourceUpdateOption
		var variadicArgs []client.SubResourceUpdateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.SubResourceUpdateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *SubResourceWriter_Update_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error) *SubResourceWriter_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceClient) EXPECT() *SubResourceClient_Expecter {
	return &SubResourceClient_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - subResource client.Object
//   - opts ...client.SubResourceCreateOption
func (_e *SubResourceClient_Expecter) Create(ctx interface{}, obj interface{}, subResource interface{}, opts ...interface{}) *SubResourceClient_Create_Call {
	return &SubResourceClient_Create_Call{Call: _e.mock.On("Create",
		append([]interface{}{ctx, obj, subResource}, opts...)...)}
}

func (_c *SubResourceClient_Create_Call) Run(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption)) *SubResourceClient_Create_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.Object
		if args[2] != nil {
			arg2 = args[2].(client.Object)
		}
		var arg3 []client.SubResourceCreateOption
		var variadicArgs []client.SubResourceCreateOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.SubResourceCreateOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *SubResourceClient_Create_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption) error) *SubResourceClient_Create_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - subResource client.Object
//   - opts ...client.SubResourceGetOption
func (_e *SubResourceClient_Expecter) Get(ctx interface{}, obj interface{}, subResource interface{}, opts ...interface{}) *SubResourceClient_Get_Call {
	return &SubResourceClient_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{ctx, obj, subResource}, opts...)...)}
}

func (_c *SubResourceClient_Get_Call) Run(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceGetOption)) *SubResourceClient_Get_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.Object
		if args[2] != nil {
			arg2 = args[2].(client.Object)
		}
		var arg3 []client.SubResourceGetOption
		var variadicArgs []client.SubResourceGetOption
		if len(args) > 3 {
			variadicArgs = args[3].([]client.SubResourceGetOption)
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

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

func (_c *SubResourceClient_Get_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, subResource client.Object, opts ...client.SubResourceGetOption) error) *SubResourceClient_Get_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type SubResourceClient
func (_mock *SubResourceClient) 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
}

// SubResourceClient_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type SubResourceClient_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 *SubResourceClient_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *SubResourceClient_Patch_Call {
	return &SubResourceClient_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *SubResourceClient_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption)) *SubResourceClient_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 *SubResourceClient_Patch_Call) Return(err error) *SubResourceClient_Patch_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

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

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

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

func (_c *SubResourceClient_Update_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption)) *SubResourceClient_Update_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.SubResourceUpdateOption
		var variadicArgs []client.SubResourceUpdateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.SubResourceUpdateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *SubResourceClient_Update_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error) *SubResourceClient_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type Client_Expecter struct {
	mock *mock.Mock
}

func (_m *Client) EXPECT() *Client_Expecter {
	return &Client_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

func (_c *Client_Create_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.CreateOption)) *Client_Create_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.CreateOption
		var variadicArgs []client.CreateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.CreateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Client_Create_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error) *Client_Create_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *Client_Delete_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.DeleteOption)) *Client_Delete_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.DeleteOption
		var variadicArgs []client.DeleteOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.DeleteOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Client_Delete_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error) *Client_Delete_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *Client_DeleteAllOf_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption)) *Client_DeleteAllOf_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.DeleteAllOfOption
		var variadicArgs []client.DeleteAllOfOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.DeleteAllOfOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Client_DeleteAllOf_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error) *Client_DeleteAllOf_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - key client.ObjectKey
//   - obj client.Object
//   - opts ...client.GetOption
func (_e *Client_Expecter) Get(ctx interface{}, key interface{}, obj interface{}, opts ...interface{}) *Client_Get_Call {
	return &Client_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{ctx, key, obj}, opts...)...)}
}

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

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

func (_c *Client_Get_Call) RunAndReturn(run func(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error) *Client_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GroupVersionKindFor provides a mock function for the type Client
func (_mock *Client) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) {
	ret := _mock.Called(obj)

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

	var r0 schema.GroupVersionKind
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) (schema.GroupVersionKind, error)); ok {
		return returnFunc(obj)
	}
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) schema.GroupVersionKind); ok {
		r0 = returnFunc(obj)
	} else {
		r0 = ret.Get(0).(schema.GroupVersionKind)
	}
	if returnFunc, ok := ret.Get(1).(func(runtime.Object) error); ok {
		r1 = returnFunc(obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GroupVersionKindFor is a helper method to define mock.On call
//   - obj runtime.Object
func (_e *Client_Expecter) GroupVersionKindFor(obj interface{}) *Client_GroupVersionKindFor_Call {
	return &Client_GroupVersionKindFor_Call{Call: _e.mock.On("GroupVersionKindFor", obj)}
}

func (_c *Client_GroupVersionKindFor_Call) Run(run func(obj runtime.Object)) *Client_GroupVersionKindFor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 runtime.Object
		if args[0] != nil {
			arg0 = args[0].(runtime.Object)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Client_GroupVersionKindFor_Call) Return(groupVersionKind schema.GroupVersionKind, err error) *Client_GroupVersionKindFor_Call {
	_c.Call.Return(groupVersionKind, err)
	return _c
}

func (_c *Client_GroupVersionKindFor_Call) RunAndReturn(run func(obj runtime.Object) (schema.GroupVersionKind, error)) *Client_GroupVersionKindFor_Call {
	_c.Call.Return(run)
	return _c
}

// IsObjectNamespaced provides a mock function for the type Client
func (_mock *Client) IsObjectNamespaced(obj runtime.Object) (bool, error) {
	ret := _mock.Called(obj)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) (bool, error)); ok {
		return returnFunc(obj)
	}
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) bool); ok {
		r0 = returnFunc(obj)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(runtime.Object) error); ok {
		r1 = returnFunc(obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IsObjectNamespaced is a helper method to define mock.On call
//   - obj runtime.Object
func (_e *Client_Expecter) IsObjectNamespaced(obj interface{}) *Client_IsObjectNamespaced_Call {
	return &Client_IsObjectNamespaced_Call{Call: _e.mock.On("IsObjectNamespaced", obj)}
}

func (_c *Client_IsObjectNamespaced_Call) Run(run func(obj runtime.Object)) *Client_IsObjectNamespaced_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 runtime.Object
		if args[0] != nil {
			arg0 = args[0].(runtime.Object)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Client_IsObjectNamespaced_Call) Return(b bool, err error) *Client_IsObjectNamespaced_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *Client_IsObjectNamespaced_Call) RunAndReturn(run func(obj runtime.Object) (bool, error)) *Client_IsObjectNamespaced_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type Client
func (_mock *Client) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, list, opts)
	} else {
		tmpRet = _mock.Called(ctx, list)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) error); ok {
		r0 = returnFunc(ctx, list, opts...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - list client.ObjectList
//   - opts ...client.ListOption
func (_e *Client_Expecter) List(ctx interface{}, list interface{}, opts ...interface{}) *Client_List_Call {
	return &Client_List_Call{Call: _e.mock.On("List",
		append([]interface{}{ctx, list}, opts...)...)}
}

func (_c *Client_List_Call) Run(run func(ctx context.Context, list client.ObjectList, opts ...client.ListOption)) *Client_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.ObjectList
		if args[1] != nil {
			arg1 = args[1].(client.ObjectList)
		}
		var arg2 []client.ListOption
		var variadicArgs []client.ListOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ListOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Client_List_Call) RunAndReturn(run func(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error) *Client_List_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type Client
func (_mock *Client) 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
}

// Client_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type Client_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 *Client_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *Client_Patch_Call {
	return &Client_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *Client_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption)) *Client_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 *Client_Patch_Call) Return(err error) *Client_Patch_Call {
	_c.Call.Return(err)
	return _c
}

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

// RESTMapper provides a mock function for the type Client
func (_mock *Client) RESTMapper() meta.RESTMapper {
	ret := _mock.Called()

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

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

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

// RESTMapper is a helper method to define mock.On call
func (_e *Client_Expecter) RESTMapper() *Client_RESTMapper_Call {
	return &Client_RESTMapper_Call{Call: _e.mock.On("RESTMapper")}
}

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

func (_c *Client_RESTMapper_Call) Return(rESTMapper meta.RESTMapper) *Client_RESTMapper_Call {
	_c.Call.Return(rESTMapper)
	return _c
}

func (_c *Client_RESTMapper_Call) RunAndReturn(run func() meta.RESTMapper) *Client_RESTMapper_Call {
	_c.Call.Return(run)
	return _c
}

// Scheme provides a mock function for the type Client
func (_mock *Client) Scheme() *runtime.Scheme {
	ret := _mock.Called()

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

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

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

// Scheme is a helper method to define mock.On call
func (_e *Client_Expecter) Scheme() *Client_Scheme_Call {
	return &Client_Scheme_Call{Call: _e.mock.On("Scheme")}
}

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

func (_c *Client_Scheme_Call) Return(scheme *runtime.Scheme) *Client_Scheme_Call {
	_c.Call.Return(scheme)
	return _c
}

func (_c *Client_Scheme_Call) RunAndReturn(run func() *runtime.Scheme) *Client_Scheme_Call {
	_c.Call.Return(run)
	return _c
}

// Status provides a mock function for the type Client
func (_mock *Client) Status() client.SubResourceWriter {
	ret := _mock.Called()

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

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

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

// Status is a helper method to define mock.On call
func (_e *Client_Expecter) Status() *Client_Status_Call {
	return &Client_Status_Call{Call: _e.mock.On("Status")}
}

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

func (_c *Client_Status_Call) Return(subResourceWriter client.SubResourceWriter) *Client_Status_Call {
	_c.Call.Return(subResourceWriter)
	return _c
}

func (_c *Client_Status_Call) RunAndReturn(run func() client.SubResourceWriter) *Client_Status_Call {
	_c.Call.Return(run)
	return _c
}

// SubResource provides a mock function for the type Client
func (_mock *Client) SubResource(subResource string) client.SubResourceClient {
	ret := _mock.Called(subResource)

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

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

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

// SubResource is a helper method to define mock.On call
//   - subResource string
func (_e *Client_Expecter) SubResource(subResource interface{}) *Client_SubResource_Call {
	return &Client_SubResource_Call{Call: _e.mock.On("SubResource", subResource)}
}

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

func (_c *Client_SubResource_Call) Return(subResourceClient client.SubResourceClient) *Client_SubResource_Call {
	_c.Call.Return(subResourceClient)
	return _c
}

func (_c *Client_SubResource_Call) RunAndReturn(run func(subResource string) client.SubResourceClient) *Client_SubResource_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *Client_Update_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.UpdateOption)) *Client_Update_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.UpdateOption
		var variadicArgs []client.UpdateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.UpdateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *Client_Update_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error) *Client_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type WithWatch_Expecter struct {
	mock *mock.Mock
}

func (_m *WithWatch) EXPECT() *WithWatch_Expecter {
	return &WithWatch_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

func (_c *WithWatch_Create_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.CreateOption)) *WithWatch_Create_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.CreateOption
		var variadicArgs []client.CreateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.CreateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *WithWatch_Create_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error) *WithWatch_Create_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *WithWatch_Delete_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.DeleteOption)) *WithWatch_Delete_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.DeleteOption
		var variadicArgs []client.DeleteOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.DeleteOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *WithWatch_Delete_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error) *WithWatch_Delete_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *WithWatch_DeleteAllOf_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption)) *WithWatch_DeleteAllOf_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.DeleteAllOfOption
		var variadicArgs []client.DeleteAllOfOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.DeleteAllOfOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *WithWatch_DeleteAllOf_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error) *WithWatch_DeleteAllOf_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - key client.ObjectKey
//   - obj client.Object
//   - opts ...client.GetOption
func (_e *WithWatch_Expecter) Get(ctx interface{}, key interface{}, obj interface{}, opts ...interface{}) *WithWatch_Get_Call {
	return &WithWatch_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{ctx, key, obj}, opts...)...)}
}

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

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

func (_c *WithWatch_Get_Call) RunAndReturn(run func(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error) *WithWatch_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GroupVersionKindFor provides a mock function for the type WithWatch
func (_mock *WithWatch) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) {
	ret := _mock.Called(obj)

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

	var r0 schema.GroupVersionKind
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) (schema.GroupVersionKind, error)); ok {
		return returnFunc(obj)
	}
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) schema.GroupVersionKind); ok {
		r0 = returnFunc(obj)
	} else {
		r0 = ret.Get(0).(schema.GroupVersionKind)
	}
	if returnFunc, ok := ret.Get(1).(func(runtime.Object) error); ok {
		r1 = returnFunc(obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GroupVersionKindFor is a helper method to define mock.On call
//   - obj runtime.Object
func (_e *WithWatch_Expecter) GroupVersionKindFor(obj interface{}) *WithWatch_GroupVersionKindFor_Call {
	return &WithWatch_GroupVersionKindFor_Call{Call: _e.mock.On("GroupVersionKindFor", obj)}
}

func (_c *WithWatch_GroupVersionKindFor_Call) Run(run func(obj runtime.Object)) *WithWatch_GroupVersionKindFor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 runtime.Object
		if args[0] != nil {
			arg0 = args[0].(runtime.Object)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *WithWatch_GroupVersionKindFor_Call) Return(groupVersionKind schema.GroupVersionKind, err error) *WithWatch_GroupVersionKindFor_Call {
	_c.Call.Return(groupVersionKind, err)
	return _c
}

func (_c *WithWatch_GroupVersionKindFor_Call) RunAndReturn(run func(obj runtime.Object) (schema.GroupVersionKind, error)) *WithWatch_GroupVersionKindFor_Call {
	_c.Call.Return(run)
	return _c
}

// IsObjectNamespaced provides a mock function for the type WithWatch
func (_mock *WithWatch) IsObjectNamespaced(obj runtime.Object) (bool, error) {
	ret := _mock.Called(obj)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) (bool, error)); ok {
		return returnFunc(obj)
	}
	if returnFunc, ok := ret.Get(0).(func(runtime.Object) bool); ok {
		r0 = returnFunc(obj)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(runtime.Object) error); ok {
		r1 = returnFunc(obj)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IsObjectNamespaced is a helper method to define mock.On call
//   - obj runtime.Object
func (_e *WithWatch_Expecter) IsObjectNamespaced(obj interface{}) *WithWatch_IsObjectNamespaced_Call {
	return &WithWatch_IsObjectNamespaced_Call{Call: _e.mock.On("IsObjectNamespaced", obj)}
}

func (_c *WithWatch_IsObjectNamespaced_Call) Run(run func(obj runtime.Object)) *WithWatch_IsObjectNamespaced_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 runtime.Object
		if args[0] != nil {
			arg0 = args[0].(runtime.Object)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *WithWatch_IsObjectNamespaced_Call) Return(b bool, err error) *WithWatch_IsObjectNamespaced_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *WithWatch_IsObjectNamespaced_Call) RunAndReturn(run func(obj runtime.Object) (bool, error)) *WithWatch_IsObjectNamespaced_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type WithWatch
func (_mock *WithWatch) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, list, opts)
	} else {
		tmpRet = _mock.Called(ctx, list)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) error); ok {
		r0 = returnFunc(ctx, list, opts...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - list client.ObjectList
//   - opts ...client.ListOption
func (_e *WithWatch_Expecter) List(ctx interface{}, list interface{}, opts ...interface{}) *WithWatch_List_Call {
	return &WithWatch_List_Call{Call: _e.mock.On("List",
		append([]interface{}{ctx, list}, opts...)...)}
}

func (_c *WithWatch_List_Call) Run(run func(ctx context.Context, list client.ObjectList, opts ...client.ListOption)) *WithWatch_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.ObjectList
		if args[1] != nil {
			arg1 = args[1].(client.ObjectList)
		}
		var arg2 []client.ListOption
		var variadicArgs []client.ListOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ListOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *WithWatch_List_Call) RunAndReturn(run func(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error) *WithWatch_List_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type WithWatch
func (_mock *WithWatch) 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
}

// WithWatch_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type WithWatch_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 *WithWatch_Expecter) Patch(ctx interface{}, obj interface{}, patch interface{}, opts ...interface{}) *WithWatch_Patch_Call {
	return &WithWatch_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, obj, patch}, opts...)...)}
}

func (_c *WithWatch_Patch_Call) Run(run func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption)) *WithWatch_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 *WithWatch_Patch_Call) Return(err error) *WithWatch_Patch_Call {
	_c.Call.Return(err)
	return _c
}

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

// RESTMapper provides a mock function for the type WithWatch
func (_mock *WithWatch) RESTMapper() meta.RESTMapper {
	ret := _mock.Called()

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

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

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

// RESTMapper is a helper method to define mock.On call
func (_e *WithWatch_Expecter) RESTMapper() *WithWatch_RESTMapper_Call {
	return &WithWatch_RESTMapper_Call{Call: _e.mock.On("RESTMapper")}
}

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

func (_c *WithWatch_RESTMapper_Call) Return(rESTMapper meta.RESTMapper) *WithWatch_RESTMapper_Call {
	_c.Call.Return(rESTMapper)
	return _c
}

func (_c *WithWatch_RESTMapper_Call) RunAndReturn(run func() meta.RESTMapper) *WithWatch_RESTMapper_Call {
	_c.Call.Return(run)
	return _c
}

// Scheme provides a mock function for the type WithWatch
func (_mock *WithWatch) Scheme() *runtime.Scheme {
	ret := _mock.Called()

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

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

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

// Scheme is a helper method to define mock.On call
func (_e *WithWatch_Expecter) Scheme() *WithWatch_Scheme_Call {
	return &WithWatch_Scheme_Call{Call: _e.mock.On("Scheme")}
}

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

func (_c *WithWatch_Scheme_Call) Return(scheme *runtime.Scheme) *WithWatch_Scheme_Call {
	_c.Call.Return(scheme)
	return _c
}

func (_c *WithWatch_Scheme_Call) RunAndReturn(run func() *runtime.Scheme) *WithWatch_Scheme_Call {
	_c.Call.Return(run)
	return _c
}

// Status provides a mock function for the type WithWatch
func (_mock *WithWatch) Status() client.SubResourceWriter {
	ret := _mock.Called()

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

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

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

// Status is a helper method to define mock.On call
func (_e *WithWatch_Expecter) Status() *WithWatch_Status_Call {
	return &WithWatch_Status_Call{Call: _e.mock.On("Status")}
}

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

func (_c *WithWatch_Status_Call) Return(subResourceWriter client.SubResourceWriter) *WithWatch_Status_Call {
	_c.Call.Return(subResourceWriter)
	return _c
}

func (_c *WithWatch_Status_Call) RunAndReturn(run func() client.SubResourceWriter) *WithWatch_Status_Call {
	_c.Call.Return(run)
	return _c
}

// SubResource provides a mock function for the type WithWatch
func (_mock *WithWatch) SubResource(subResource string) client.SubResourceClient {
	ret := _mock.Called(subResource)

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

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

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

// SubResource is a helper method to define mock.On call
//   - subResource string
func (_e *WithWatch_Expecter) SubResource(subResource interface{}) *WithWatch_SubResource_Call {
	return &WithWatch_SubResource_Call{Call: _e.mock.On("SubResource", subResource)}
}

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

func (_c *WithWatch_SubResource_Call) Return(subResourceClient client.SubResourceClient) *WithWatch_SubResource_Call {
	_c.Call.Return(subResourceClient)
	return _c
}

func (_c *WithWatch_SubResource_Call) RunAndReturn(run func(subResource string) client.SubResourceClient) *WithWatch_SubResource_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *WithWatch_Update_Call) Run(run func(ctx context.Context, obj client.Object, opts ...client.UpdateOption)) *WithWatch_Update_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.UpdateOption
		var variadicArgs []client.UpdateOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.UpdateOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *WithWatch_Update_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error) *WithWatch_Update_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function for the type WithWatch
func (_mock *WithWatch) Watch(ctx context.Context, obj client.ObjectList, opts ...client.ListOption) (watch.Interface, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, obj, opts)
	} else {
		tmpRet = _mock.Called(ctx, obj)
	}
	ret := tmpRet

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

	var r0 watch.Interface
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) (watch.Interface, error)); ok {
		return returnFunc(ctx, obj, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) watch.Interface); ok {
		r0 = returnFunc(ctx, obj, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(watch.Interface)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, client.ObjectList, ...client.ListOption) error); ok {
		r1 = returnFunc(ctx, obj, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Watch is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.ObjectList
//   - opts ...client.ListOption
func (_e *WithWatch_Expecter) Watch(ctx interface{}, obj interface{}, opts ...interface{}) *WithWatch_Watch_Call {
	return &WithWatch_Watch_Call{Call: _e.mock.On("Watch",
		append([]interface{}{ctx, obj}, opts...)...)}
}

func (_c *WithWatch_Watch_Call) Run(run func(ctx context.Context, obj client.ObjectList, opts ...client.ListOption)) *WithWatch_Watch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.ObjectList
		if args[1] != nil {
			arg1 = args[1].(client.ObjectList)
		}
		var arg2 []client.ListOption
		var variadicArgs []client.ListOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ListOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *WithWatch_Watch_Call) Return(interfaceParam watch.Interface, err error) *WithWatch_Watch_Call {
	_c.Call.Return(interfaceParam, err)
	return _c
}

func (_c *WithWatch_Watch_Call) RunAndReturn(run func(ctx context.Context, obj client.ObjectList, opts ...client.ListOption) (watch.Interface, error)) *WithWatch_Watch_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type FieldIndexer_Expecter struct {
	mock *mock.Mock
}

func (_m *FieldIndexer) EXPECT() *FieldIndexer_Expecter {
	return &FieldIndexer_Expecter{mock: &_m.Mock}
}

// IndexField provides a mock function for the type FieldIndexer
func (_mock *FieldIndexer) IndexField(ctx context.Context, obj client.Object, field string, extractValue client.IndexerFunc) error {
	ret := _mock.Called(ctx, obj, field, extractValue)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.Object, string, client.IndexerFunc) error); ok {
		r0 = returnFunc(ctx, obj, field, extractValue)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// IndexField is a helper method to define mock.On call
//   - ctx context.Context
//   - obj client.Object
//   - field string
//   - extractValue client.IndexerFunc
func (_e *FieldIndexer_Expecter) IndexField(ctx interface{}, obj interface{}, field interface{}, extractValue interface{}) *FieldIndexer_IndexField_Call {
	return &FieldIndexer_IndexField_Call{Call: _e.mock.On("IndexField", ctx, obj, field, extractValue)}
}

func (_c *FieldIndexer_IndexField_Call) Run(run func(ctx context.Context, obj client.Object, field string, extractValue client.IndexerFunc)) *FieldIndexer_IndexField_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 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 client.IndexerFunc
		if args[3] != nil {
			arg3 = args[3].(client.IndexerFunc)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *FieldIndexer_IndexField_Call) RunAndReturn(run func(ctx context.Context, obj client.Object, field string, extractValue client.IndexerFunc) error) *FieldIndexer_IndexField_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type Object_Expecter struct {
	mock *mock.Mock
}

func (_m *Object) EXPECT() *Object_Expecter {
	return &Object_Expecter{mock: &_m.Mock}
}

// DeepCopyObject provides a mock function for the type Object
func (_mock *Object) 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
}

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

// DeepCopyObject is a helper method to define mock.On call
func (_e *Object_Expecter) DeepCopyObject() *Object_DeepCopyObject_Call {
	return &Object_DeepCopyObject_Call{Call: _e.mock.On("DeepCopyObject")}
}

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

func (_c *Object_DeepCopyObject_Call) Return(object runtime.Object) *Object_DeepCopyObject_Call {
	_c.Call.Return(object)
	return _c
}

func (_c *Object_DeepCopyObject_Call) RunAndReturn(run func() runtime.Object) *Object_DeepCopyObject_Call {
	_c.Call.Return(run)
	return _c
}

// GetAnnotations provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetAnnotations is a helper method to define mock.On call
func (_e *Object_Expecter) GetAnnotations() *Object_GetAnnotations_Call {
	return &Object_GetAnnotations_Call{Call: _e.mock.On("GetAnnotations")}
}

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

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

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

// GetCreationTimestamp provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetCreationTimestamp is a helper method to define mock.On call
func (_e *Object_Expecter) GetCreationTimestamp() *Object_GetCreationTimestamp_Call {
	return &Object_GetCreationTimestamp_Call{Call: _e.mock.On("GetCreationTimestamp")}
}

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

func (_c *Object_GetCreationTimestamp_Call) Return(time v1.Time) *Object_GetCreationTimestamp_Call {
	_c.Call.Return(time)
	return _c
}

func (_c *Object_GetCreationTimestamp_Call) RunAndReturn(run func() v1.Time) *Object_GetCreationTimestamp_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeletionGracePeriodSeconds provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetDeletionGracePeriodSeconds is a helper method to define mock.On call
func (_e *Object_Expecter) GetDeletionGracePeriodSeconds() *Object_GetDeletionGracePeriodSeconds_Call {
	return &Object_GetDeletionGracePeriodSeconds_Call{Call: _e.mock.On("GetDeletionGracePeriodSeconds")}
}

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

func (_c *Object_GetDeletionGracePeriodSeconds_Call) Return(n *int64) *Object_GetDeletionGracePeriodSeconds_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *Object_GetDeletionGracePeriodSeconds_Call) RunAndReturn(run func() *int64) *Object_GetDeletionGracePeriodSeconds_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeletionTimestamp provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetDeletionTimestamp is a helper method to define mock.On call
func (_e *Object_Expecter) GetDeletionTimestamp() *Object_GetDeletionTimestamp_Call {
	return &Object_GetDeletionTimestamp_Call{Call: _e.mock.On("GetDeletionTimestamp")}
}

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

func (_c *Object_GetDeletionTimestamp_Call) Return(time *v1.Time) *Object_GetDeletionTimestamp_Call {
	_c.Call.Return(time)
	return _c
}

func (_c *Object_GetDeletionTimestamp_Call) RunAndReturn(run func() *v1.Time) *Object_GetDeletionTimestamp_Call {
	_c.Call.Return(run)
	return _c
}

// GetFinalizers provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetFinalizers is a helper method to define mock.On call
func (_e *Object_Expecter) GetFinalizers() *Object_GetFinalizers_Call {
	return &Object_GetFinalizers_Call{Call: _e.mock.On("GetFinalizers")}
}

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

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

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

// GetGenerateName provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetGenerateName is a helper method to define mock.On call
func (_e *Object_Expecter) GetGenerateName() *Object_GetGenerateName_Call {
	return &Object_GetGenerateName_Call{Call: _e.mock.On("GetGenerateName")}
}

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

func (_c *Object_GetGenerateName_Call) Return(s string) *Object_GetGenerateName_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *Object_GetGenerateName_Call) RunAndReturn(run func() string) *Object_GetGenerateName_Call {
	_c.Call.Return(run)
	return _c
}

// GetGeneration provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetGeneration is a helper method to define mock.On call
func (_e *Object_Expecter) GetGeneration() *Object_GetGeneration_Call {
	return &Object_GetGeneration_Call{Call: _e.mock.On("GetGeneration")}
}

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

func (_c *Object_GetGeneration_Call) Return(n int64) *Object_GetGeneration_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *Object_GetGeneration_Call) RunAndReturn(run func() int64) *Object_GetGeneration_Call {
	_c.Call.Return(run)
	return _c
}

// GetLabels provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetLabels is a helper method to define mock.On call
func (_e *Object_Expecter) GetLabels() *Object_GetLabels_Call {
	return &Object_GetLabels_Call{Call: _e.mock.On("GetLabels")}
}

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

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

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

// GetManagedFields provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetManagedFields is a helper method to define mock.On call
func (_e *Object_Expecter) GetManagedFields() *Object_GetManagedFields_Call {
	return &Object_GetManagedFields_Call{Call: _e.mock.On("GetManagedFields")}
}

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

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

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

// GetName provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetName is a helper method to define mock.On call
func (_e *Object_Expecter) GetName() *Object_GetName_Call {
	return &Object_GetName_Call{Call: _e.mock.On("GetName")}
}

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

func (_c *Object_GetName_Call) Return(s string) *Object_GetName_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *Object_GetName_Call) RunAndReturn(run func() string) *Object_GetName_Call {
	_c.Call.Return(run)
	return _c
}

// GetNamespace provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetNamespace is a helper method to define mock.On call
func (_e *Object_Expecter) GetNamespace() *Object_GetNamespace_Call {
	return &Object_GetNamespace_Call{Call: _e.mock.On("GetNamespace")}
}

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

func (_c *Object_GetNamespace_Call) Return(s string) *Object_GetNamespace_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *Object_GetNamespace_Call) RunAndReturn(run func() string) *Object_GetNamespace_Call {
	_c.Call.Return(run)
	return _c
}

// GetObjectKind provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetObjectKind is a helper method to define mock.On call
func (_e *Object_Expecter) GetObjectKind() *Object_GetObjectKind_Call {
	return &Object_GetObjectKind_Call{Call: _e.mock.On("GetObjectKind")}
}

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

func (_c *Object_GetObjectKind_Call) Return(objectKind schema.ObjectKind) *Object_GetObjectKind_Call {
	_c.Call.Return(objectKind)
	return _c
}

func (_c *Object_GetObjectKind_Call) RunAndReturn(run func() schema.ObjectKind) *Object_GetObjectKind_Call {
	_c.Call.Return(run)
	return _c
}

// GetOwnerReferences provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetOwnerReferences is a helper method to define mock.On call
func (_e *Object_Expecter) GetOwnerReferences() *Object_GetOwnerReferences_Call {
	return &Object_GetOwnerReferences_Call{Call: _e.mock.On("GetOwnerReferences")}
}

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

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

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

// GetResourceVersion provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetResourceVersion is a helper method to define mock.On call
func (_e *Object_Expecter) GetResourceVersion() *Object_GetResourceVersion_Call {
	return &Object_GetResourceVersion_Call{Call: _e.mock.On("GetResourceVersion")}
}

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

func (_c *Object_GetResourceVersion_Call) Return(s string) *Object_GetResourceVersion_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *Object_GetResourceVersion_Call) RunAndReturn(run func() string) *Object_GetResourceVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetSelfLink provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetSelfLink is a helper method to define mock.On call
func (_e *Object_Expecter) GetSelfLink() *Object_GetSelfLink_Call {
	return &Object_GetSelfLink_Call{Call: _e.mock.On("GetSelfLink")}
}

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

func (_c *Object_GetSelfLink_Call) Return(s string) *Object_GetSelfLink_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *Object_GetSelfLink_Call) RunAndReturn(run func() string) *Object_GetSelfLink_Call {
	_c.Call.Return(run)
	return _c
}

// GetUID provides a mock function for the type Object
func (_mock *Object) 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
}

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

// GetUID is a helper method to define mock.On call
func (_e *Object_Expecter) GetUID() *Object_GetUID_Call {
	return &Object_GetUID_Call{Call: _e.mock.On("GetUID")}
}

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

func (_c *Object_GetUID_Call) Return(uID types.UID) *Object_GetUID_Call {
	_c.Call.Return(uID)
	return _c
}

func (_c *Object_GetUID_Call) RunAndReturn(run func() types.UID) *Object_GetUID_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

func (_c *Object_SetAnnotations_Call) Run(run func(annotations map[string]string)) *Object_SetAnnotations_Call {
	_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 *Object_SetAnnotations_Call) Return() *Object_SetAnnotations_Call {
	_c.Call.Return()
	return _c
}

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

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

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

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

func (_c *Object_SetCreationTimestamp_Call) Run(run func(timestamp v1.Time)) *Object_SetCreationTimestamp_Call {
	_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 *Object_SetCreationTimestamp_Call) Return() *Object_SetCreationTimestamp_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetCreationTimestamp_Call) RunAndReturn(run func(timestamp v1.Time)) *Object_SetCreationTimestamp_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *Object_SetDeletionGracePeriodSeconds_Call) Return() *Object_SetDeletionGracePeriodSeconds_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetDeletionGracePeriodSeconds_Call) RunAndReturn(run func(n *int64)) *Object_SetDeletionGracePeriodSeconds_Call {
	_c.Run(run)
	return _c
}

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

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

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

func (_c *Object_SetDeletionTimestamp_Call) Run(run func(timestamp *v1.Time)) *Object_SetDeletionTimestamp_Call {
	_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 *Object_SetDeletionTimestamp_Call) Return() *Object_SetDeletionTimestamp_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetDeletionTimestamp_Call) RunAndReturn(run func(timestamp *v1.Time)) *Object_SetDeletionTimestamp_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *Object_SetFinalizers_Call) Return() *Object_SetFinalizers_Call {
	_c.Call.Return()
	return _c
}

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

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

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

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

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

func (_c *Object_SetGenerateName_Call) Return() *Object_SetGenerateName_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetGenerateName_Call) RunAndReturn(run func(name string)) *Object_SetGenerateName_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *Object_SetGeneration_Call) Return() *Object_SetGeneration_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetGeneration_Call) RunAndReturn(run func(generation int64)) *Object_SetGeneration_Call {
	_c.Run(run)
	return _c
}

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

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

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

func (_c *Object_SetLabels_Call) Run(run func(labels map[string]string)) *Object_SetLabels_Call {
	_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 *Object_SetLabels_Call) Return() *Object_SetLabels_Call {
	_c.Call.Return()
	return _c
}

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

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

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

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

func (_c *Object_SetManagedFields_Call) Run(run func(managedFields []v1.ManagedFieldsEntry)) *Object_SetManagedFields_Call {
	_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 *Object_SetManagedFields_Call) Return() *Object_SetManagedFields_Call {
	_c.Call.Return()
	return _c
}

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

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

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

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

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

func (_c *Object_SetName_Call) Return() *Object_SetName_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetName_Call) RunAndReturn(run func(name string)) *Object_SetName_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *Object_SetNamespace_Call) Return() *Object_SetNamespace_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetNamespace_Call) RunAndReturn(run func(namespace string)) *Object_SetNamespace_Call {
	_c.Run(run)
	return _c
}

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

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

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

func (_c *Object_SetOwnerReferences_Call) Run(run func(ownerReferences []v1.OwnerReference)) *Object_SetOwnerReferences_Call {
	_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 *Object_SetOwnerReferences_Call) Return() *Object_SetOwnerReferences_Call {
	_c.Call.Return()
	return _c
}

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

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

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

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

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

func (_c *Object_SetResourceVersion_Call) Return() *Object_SetResourceVersion_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetResourceVersion_Call) RunAndReturn(run func(version string)) *Object_SetResourceVersion_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *Object_SetSelfLink_Call) Return() *Object_SetSelfLink_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetSelfLink_Call) RunAndReturn(run func(selfLink string)) *Object_SetSelfLink_Call {
	_c.Run(run)
	return _c
}

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

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

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

func (_c *Object_SetUID_Call) Run(run func(uid types.UID)) *Object_SetUID_Call {
	_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 *Object_SetUID_Call) Return() *Object_SetUID_Call {
	_c.Call.Return()
	return _c
}

func (_c *Object_SetUID_Call) RunAndReturn(run func(uid types.UID)) *Object_SetUID_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type ObjectList_Expecter struct {
	mock *mock.Mock
}

func (_m *ObjectList) EXPECT() *ObjectList_Expecter {
	return &ObjectList_Expecter{mock: &_m.Mock}
}

// DeepCopyObject provides a mock function for the type ObjectList
func (_mock *ObjectList) 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
}

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

// DeepCopyObject is a helper method to define mock.On call
func (_e *ObjectList_Expecter) DeepCopyObject() *ObjectList_DeepCopyObject_Call {
	return &ObjectList_DeepCopyObject_Call{Call: _e.mock.On("DeepCopyObject")}
}

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

func (_c *ObjectList_DeepCopyObject_Call) Return(object runtime.Object) *ObjectList_DeepCopyObject_Call {
	_c.Call.Return(object)
	return _c
}

func (_c *ObjectList_DeepCopyObject_Call) RunAndReturn(run func() runtime.Object) *ObjectList_DeepCopyObject_Call {
	_c.Call.Return(run)
	return _c
}

// GetContinue provides a mock function for the type ObjectList
func (_mock *ObjectList) GetContinue() string {
	ret := _mock.Called()

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

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

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

// GetContinue is a helper method to define mock.On call
func (_e *ObjectList_Expecter) GetContinue() *ObjectList_GetContinue_Call {
	return &ObjectList_GetContinue_Call{Call: _e.mock.On("GetContinue")}
}

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

func (_c *ObjectList_GetContinue_Call) Return(s string) *ObjectList_GetContinue_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *ObjectList_GetContinue_Call) RunAndReturn(run func() string) *ObjectList_GetContinue_Call {
	_c.Call.Return(run)
	return _c
}

// GetObjectKind provides a mock function for the type ObjectList
func (_mock *ObjectList) 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
}

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

// GetObjectKind is a helper method to define mock.On call
func (_e *ObjectList_Expecter) GetObjectKind() *ObjectList_GetObjectKind_Call {
	return &ObjectList_GetObjectKind_Call{Call: _e.mock.On("GetObjectKind")}
}

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

func (_c *ObjectList_GetObjectKind_Call) Return(objectKind schema.ObjectKind) *ObjectList_GetObjectKind_Call {
	_c.Call.Return(objectKind)
	return _c
}

func (_c *ObjectList_GetObjectKind_Call) RunAndReturn(run func() schema.ObjectKind) *ObjectList_GetObjectKind_Call {
	_c.Call.Return(run)
	return _c
}

// GetRemainingItemCount provides a mock function for the type ObjectList
func (_mock *ObjectList) GetRemainingItemCount() *int64 {
	ret := _mock.Called()

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

	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
}

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

// GetRemainingItemCount is a helper method to define mock.On call
func (_e *ObjectList_Expecter) GetRemainingItemCount() *ObjectList_GetRemainingItemCount_Call {
	return &ObjectList_GetRemainingItemCount_Call{Call: _e.mock.On("GetRemainingItemCount")}
}

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

func (_c *ObjectList_GetRemainingItemCount_Call) Return(n *int64) *ObjectList_GetRemainingItemCount_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *ObjectList_GetRemainingItemCount_Call) RunAndReturn(run func() *int64) *ObjectList_GetRemainingItemCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetResourceVersion provides a mock function for the type ObjectList
func (_mock *ObjectList) 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
}

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

// GetResourceVersion is a helper method to define mock.On call
func (_e *ObjectList_Expecter) GetResourceVersion() *ObjectList_GetResourceVersion_Call {
	return &ObjectList_GetResourceVersion_Call{Call: _e.mock.On("GetResourceVersion")}
}

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

func (_c *ObjectList_GetResourceVersion_Call) Return(s string) *ObjectList_GetResourceVersion_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *ObjectList_GetResourceVersion_Call) RunAndReturn(run func() string) *ObjectList_GetResourceVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetSelfLink provides a mock function for the type ObjectList
func (_mock *ObjectList) 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
}

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

// GetSelfLink is a helper method to define mock.On call
func (_e *ObjectList_Expecter) GetSelfLink() *ObjectList_GetSelfLink_Call {
	return &ObjectList_GetSelfLink_Call{Call: _e.mock.On("GetSelfLink")}
}

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

func (_c *ObjectList_GetSelfLink_Call) Return(s string) *ObjectList_GetSelfLink_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *ObjectList_GetSelfLink_Call) RunAndReturn(run func() string) *ObjectList_GetSelfLink_Call {
	_c.Call.Return(run)
	return _c
}

// SetContinue provides a mock function for the type ObjectList
func (_mock *ObjectList) SetContinue(c string) {
	_mock.Called(c)
	return
}

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

// SetContinue is a helper method to define mock.On call
//   - c string
func (_e *ObjectList_Expecter) SetContinue(c interface{}) *ObjectList_SetContinue_Call {
	return &ObjectList_SetContinue_Call{Call: _e.mock.On("SetContinue", c)}
}

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

func (_c *ObjectList_SetContinue_Call) Return() *ObjectList_SetContinue_Call {
	_c.Call.Return()
	return _c
}

func (_c *ObjectList_SetContinue_Call) RunAndReturn(run func(c string)) *ObjectList_SetContinue_Call {
	_c.Run(run)
	return _c
}

// SetRemainingItemCount provides a mock function for the type ObjectList
func (_mock *ObjectList) SetRemainingItemCount(c *int64) {
	_mock.Called(c)
	return
}

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

// SetRemainingItemCount is a helper method to define mock.On call
//   - c *int64
func (_e *ObjectList_Expecter) SetRemainingItemCount(c interface{}) *ObjectList_SetRemainingItemCount_Call {
	return &ObjectList_SetRemainingItemCount_Call{Call: _e.mock.On("SetRemainingItemCount", c)}
}

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

func (_c *ObjectList_SetRemainingItemCount_Call) Return() *ObjectList_SetRemainingItemCount_Call {
	_c.Call.Return()
	return _c
}

func (_c *ObjectList_SetRemainingItemCount_Call) RunAndReturn(run func(c *int64)) *ObjectList_SetRemainingItemCount_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *ObjectList_SetResourceVersion_Call) Return() *ObjectList_SetResourceVersion_Call {
	_c.Call.Return()
	return _c
}

func (_c *ObjectList_SetResourceVersion_Call) RunAndReturn(run func(version string)) *ObjectList_SetResourceVersion_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

func (_c *ObjectList_SetSelfLink_Call) Return() *ObjectList_SetSelfLink_Call {
	_c.Call.Return()
	return _c
}

func (_c *ObjectList_SetSelfLink_Call) RunAndReturn(run func(selfLink string)) *ObjectList_SetSelfLink_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type CreateOption_Expecter struct {
	mock *mock.Mock
}

func (_m *CreateOption) EXPECT() *CreateOption_Expecter {
	return &CreateOption_Expecter{mock: &_m.Mock}
}

// ApplyToCreate provides a mock function for the type CreateOption
func (_mock *CreateOption) ApplyToCreate(createOptions *client.CreateOptions) {
	_mock.Called(createOptions)
	return
}

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

// ApplyToCreate is a helper method to define mock.On call
//   - createOptions *client.CreateOptions
func (_e *CreateOption_Expecter) ApplyToCreate(createOptions interface{}) *CreateOption_ApplyToCreate_Call {
	return &CreateOption_ApplyToCreate_Call{Call: _e.mock.On("ApplyToCreate", createOptions)}
}

func (_c *CreateOption_ApplyToCreate_Call) Run(run func(createOptions *client.CreateOptions)) *CreateOption_ApplyToCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.CreateOptions
		if args[0] != nil {
			arg0 = args[0].(*client.CreateOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *CreateOption_ApplyToCreate_Call) Return() *CreateOption_ApplyToCreate_Call {
	_c.Call.Return()
	return _c
}

func (_c *CreateOption_ApplyToCreate_Call) RunAndReturn(run func(createOptions *client.CreateOptions)) *CreateOption_ApplyToCreate_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type DeleteOption_Expecter struct {
	mock *mock.Mock
}

func (_m *DeleteOption) EXPECT() *DeleteOption_Expecter {
	return &DeleteOption_Expecter{mock: &_m.Mock}
}

// ApplyToDelete provides a mock function for the type DeleteOption
func (_mock *DeleteOption) ApplyToDelete(deleteOptions *client.DeleteOptions) {
	_mock.Called(deleteOptions)
	return
}

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

// ApplyToDelete is a helper method to define mock.On call
//   - deleteOptions *client.DeleteOptions
func (_e *DeleteOption_Expecter) ApplyToDelete(deleteOptions interface{}) *DeleteOption_ApplyToDelete_Call {
	return &DeleteOption_ApplyToDelete_Call{Call: _e.mock.On("ApplyToDelete", deleteOptions)}
}

func (_c *DeleteOption_ApplyToDelete_Call) Run(run func(deleteOptions *client.DeleteOptions)) *DeleteOption_ApplyToDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.DeleteOptions
		if args[0] != nil {
			arg0 = args[0].(*client.DeleteOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *DeleteOption_ApplyToDelete_Call) Return() *DeleteOption_ApplyToDelete_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeleteOption_ApplyToDelete_Call) RunAndReturn(run func(deleteOptions *client.DeleteOptions)) *DeleteOption_ApplyToDelete_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type GetOption_Expecter struct {
	mock *mock.Mock
}

func (_m *GetOption) EXPECT() *GetOption_Expecter {
	return &GetOption_Expecter{mock: &_m.Mock}
}

// ApplyToGet provides a mock function for the type GetOption
func (_mock *GetOption) ApplyToGet(getOptions *client.GetOptions) {
	_mock.Called(getOptions)
	return
}

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

// ApplyToGet is a helper method to define mock.On call
//   - getOptions *client.GetOptions
func (_e *GetOption_Expecter) ApplyToGet(getOptions interface{}) *GetOption_ApplyToGet_Call {
	return &GetOption_ApplyToGet_Call{Call: _e.mock.On("ApplyToGet", getOptions)}
}

func (_c *GetOption_ApplyToGet_Call) Run(run func(getOptions *client.GetOptions)) *GetOption_ApplyToGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.GetOptions
		if args[0] != nil {
			arg0 = args[0].(*client.GetOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *GetOption_ApplyToGet_Call) Return() *GetOption_ApplyToGet_Call {
	_c.Call.Return()
	return _c
}

func (_c *GetOption_ApplyToGet_Call) RunAndReturn(run func(getOptions *client.GetOptions)) *GetOption_ApplyToGet_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type ListOption_Expecter struct {
	mock *mock.Mock
}

func (_m *ListOption) EXPECT() *ListOption_Expecter {
	return &ListOption_Expecter{mock: &_m.Mock}
}

// ApplyToList provides a mock function for the type ListOption
func (_mock *ListOption) ApplyToList(listOptions *client.ListOptions) {
	_mock.Called(listOptions)
	return
}

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

// ApplyToList is a helper method to define mock.On call
//   - listOptions *client.ListOptions
func (_e *ListOption_Expecter) ApplyToList(listOptions interface{}) *ListOption_ApplyToList_Call {
	return &ListOption_ApplyToList_Call{Call: _e.mock.On("ApplyToList", listOptions)}
}

func (_c *ListOption_ApplyToList_Call) Run(run func(listOptions *client.ListOptions)) *ListOption_ApplyToList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.ListOptions
		if args[0] != nil {
			arg0 = args[0].(*client.ListOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *ListOption_ApplyToList_Call) Return() *ListOption_ApplyToList_Call {
	_c.Call.Return()
	return _c
}

func (_c *ListOption_ApplyToList_Call) RunAndReturn(run func(listOptions *client.ListOptions)) *ListOption_ApplyToList_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type UpdateOption_Expecter struct {
	mock *mock.Mock
}

func (_m *UpdateOption) EXPECT() *UpdateOption_Expecter {
	return &UpdateOption_Expecter{mock: &_m.Mock}
}

// ApplyToUpdate provides a mock function for the type UpdateOption
func (_mock *UpdateOption) ApplyToUpdate(updateOptions *client.UpdateOptions) {
	_mock.Called(updateOptions)
	return
}

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

// ApplyToUpdate is a helper method to define mock.On call
//   - updateOptions *client.UpdateOptions
func (_e *UpdateOption_Expecter) ApplyToUpdate(updateOptions interface{}) *UpdateOption_ApplyToUpdate_Call {
	return &UpdateOption_ApplyToUpdate_Call{Call: _e.mock.On("ApplyToUpdate", updateOptions)}
}

func (_c *UpdateOption_ApplyToUpdate_Call) Run(run func(updateOptions *client.UpdateOptions)) *UpdateOption_ApplyToUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.UpdateOptions
		if args[0] != nil {
			arg0 = args[0].(*client.UpdateOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *UpdateOption_ApplyToUpdate_Call) Return() *UpdateOption_ApplyToUpdate_Call {
	_c.Call.Return()
	return _c
}

func (_c *UpdateOption_ApplyToUpdate_Call) RunAndReturn(run func(updateOptions *client.UpdateOptions)) *UpdateOption_ApplyToUpdate_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type PatchOption_Expecter struct {
	mock *mock.Mock
}

func (_m *PatchOption) EXPECT() *PatchOption_Expecter {
	return &PatchOption_Expecter{mock: &_m.Mock}
}

// ApplyToPatch provides a mock function for the type PatchOption
func (_mock *PatchOption) ApplyToPatch(patchOptions *client.PatchOptions) {
	_mock.Called(patchOptions)
	return
}

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

// ApplyToPatch is a helper method to define mock.On call
//   - patchOptions *client.PatchOptions
func (_e *PatchOption_Expecter) ApplyToPatch(patchOptions interface{}) *PatchOption_ApplyToPatch_Call {
	return &PatchOption_ApplyToPatch_Call{Call: _e.mock.On("ApplyToPatch", patchOptions)}
}

func (_c *PatchOption_ApplyToPatch_Call) Run(run func(patchOptions *client.PatchOptions)) *PatchOption_ApplyToPatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.PatchOptions
		if args[0] != nil {
			arg0 = args[0].(*client.PatchOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *PatchOption_ApplyToPatch_Call) Return() *PatchOption_ApplyToPatch_Call {
	_c.Call.Return()
	return _c
}

func (_c *PatchOption_ApplyToPatch_Call) RunAndReturn(run func(patchOptions *client.PatchOptions)) *PatchOption_ApplyToPatch_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type DeleteAllOfOption_Expecter struct {
	mock *mock.Mock
}

func (_m *DeleteAllOfOption) EXPECT() *DeleteAllOfOption_Expecter {
	return &DeleteAllOfOption_Expecter{mock: &_m.Mock}
}

// ApplyToDeleteAllOf provides a mock function for the type DeleteAllOfOption
func (_mock *DeleteAllOfOption) ApplyToDeleteAllOf(deleteAllOfOptions *client.DeleteAllOfOptions) {
	_mock.Called(deleteAllOfOptions)
	return
}

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

// ApplyToDeleteAllOf is a helper method to define mock.On call
//   - deleteAllOfOptions *client.DeleteAllOfOptions
func (_e *DeleteAllOfOption_Expecter) ApplyToDeleteAllOf(deleteAllOfOptions interface{}) *DeleteAllOfOption_ApplyToDeleteAllOf_Call {
	return &DeleteAllOfOption_ApplyToDeleteAllOf_Call{Call: _e.mock.On("ApplyToDeleteAllOf", deleteAllOfOptions)}
}

func (_c *DeleteAllOfOption_ApplyToDeleteAllOf_Call) Run(run func(deleteAllOfOptions *client.DeleteAllOfOptions)) *DeleteAllOfOption_ApplyToDeleteAllOf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.DeleteAllOfOptions
		if args[0] != nil {
			arg0 = args[0].(*client.DeleteAllOfOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *DeleteAllOfOption_ApplyToDeleteAllOf_Call) Return() *DeleteAllOfOption_ApplyToDeleteAllOf_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeleteAllOfOption_ApplyToDeleteAllOf_Call) RunAndReturn(run func(deleteAllOfOptions *client.DeleteAllOfOptions)) *DeleteAllOfOption_ApplyToDeleteAllOf_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceGetOption_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceGetOption) EXPECT() *SubResourceGetOption_Expecter {
	return &SubResourceGetOption_Expecter{mock: &_m.Mock}
}

// ApplyToSubResourceGet provides a mock function for the type SubResourceGetOption
func (_mock *SubResourceGetOption) ApplyToSubResourceGet(subResourceGetOptions *client.SubResourceGetOptions) {
	_mock.Called(subResourceGetOptions)
	return
}

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

// ApplyToSubResourceGet is a helper method to define mock.On call
//   - subResourceGetOptions *client.SubResourceGetOptions
func (_e *SubResourceGetOption_Expecter) ApplyToSubResourceGet(subResourceGetOptions interface{}) *SubResourceGetOption_ApplyToSubResourceGet_Call {
	return &SubResourceGetOption_ApplyToSubResourceGet_Call{Call: _e.mock.On("ApplyToSubResourceGet", subResourceGetOptions)}
}

func (_c *SubResourceGetOption_ApplyToSubResourceGet_Call) Run(run func(subResourceGetOptions *client.SubResourceGetOptions)) *SubResourceGetOption_ApplyToSubResourceGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.SubResourceGetOptions
		if args[0] != nil {
			arg0 = args[0].(*client.SubResourceGetOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SubResourceGetOption_ApplyToSubResourceGet_Call) Return() *SubResourceGetOption_ApplyToSubResourceGet_Call {
	_c.Call.Return()
	return _c
}

func (_c *SubResourceGetOption_ApplyToSubResourceGet_Call) RunAndReturn(run func(subResourceGetOptions *client.SubResourceGetOptions)) *SubResourceGetOption_ApplyToSubResourceGet_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceUpdateOption_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceUpdateOption) EXPECT() *SubResourceUpdateOption_Expecter {
	return &SubResourceUpdateOption_Expecter{mock: &_m.Mock}
}

// ApplyToSubResourceUpdate provides a mock function for the type SubResourceUpdateOption
func (_mock *SubResourceUpdateOption) ApplyToSubResourceUpdate(subResourceUpdateOptions *client.SubResourceUpdateOptions) {
	_mock.Called(subResourceUpdateOptions)
	return
}

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

// ApplyToSubResourceUpdate is a helper method to define mock.On call
//   - subResourceUpdateOptions *client.SubResourceUpdateOptions
func (_e *SubResourceUpdateOption_Expecter) ApplyToSubResourceUpdate(subResourceUpdateOptions interface{}) *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call {
	return &SubResourceUpdateOption_ApplyToSubResourceUpdate_Call{Call: _e.mock.On("ApplyToSubResourceUpdate", subResourceUpdateOptions)}
}

func (_c *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call) Run(run func(subResourceUpdateOptions *client.SubResourceUpdateOptions)) *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.SubResourceUpdateOptions
		if args[0] != nil {
			arg0 = args[0].(*client.SubResourceUpdateOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call) Return() *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call {
	_c.Call.Return()
	return _c
}

func (_c *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call) RunAndReturn(run func(subResourceUpdateOptions *client.SubResourceUpdateOptions)) *SubResourceUpdateOption_ApplyToSubResourceUpdate_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type SubResourceCreateOption_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourceCreateOption) EXPECT() *SubResourceCreateOption_Expecter {
	return &SubResourceCreateOption_Expecter{mock: &_m.Mock}
}

// ApplyToSubResourceCreate provides a mock function for the type SubResourceCreateOption
func (_mock *SubResourceCreateOption) ApplyToSubResourceCreate(subResourceCreateOptions *client.SubResourceCreateOptions) {
	_mock.Called(subResourceCreateOptions)
	return
}

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

// ApplyToSubResourceCreate is a helper method to define mock.On call
//   - subResourceCreateOptions *client.SubResourceCreateOptions
func (_e *SubResourceCreateOption_Expecter) ApplyToSubResourceCreate(subResourceCreateOptions interface{}) *SubResourceCreateOption_ApplyToSubResourceCreate_Call {
	return &SubResourceCreateOption_ApplyToSubResourceCreate_Call{Call: _e.mock.On("ApplyToSubResourceCreate", subResourceCreateOptions)}
}

func (_c *SubResourceCreateOption_ApplyToSubResourceCreate_Call) Run(run func(subResourceCreateOptions *client.SubResourceCreateOptions)) *SubResourceCreateOption_ApplyToSubResourceCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.SubResourceCreateOptions
		if args[0] != nil {
			arg0 = args[0].(*client.SubResourceCreateOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SubResourceCreateOption_ApplyToSubResourceCreate_Call) Return() *SubResourceCreateOption_ApplyToSubResourceCreate_Call {
	_c.Call.Return()
	return _c
}

func (_c *SubResourceCreateOption_ApplyToSubResourceCreate_Call) RunAndReturn(run func(subResourceCreateOptions *client.SubResourceCreateOptions)) *SubResourceCreateOption_ApplyToSubResourceCreate_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type SubResourcePatchOption_Expecter struct {
	mock *mock.Mock
}

func (_m *SubResourcePatchOption) EXPECT() *SubResourcePatchOption_Expecter {
	return &SubResourcePatchOption_Expecter{mock: &_m.Mock}
}

// ApplyToSubResourcePatch provides a mock function for the type SubResourcePatchOption
func (_mock *SubResourcePatchOption) ApplyToSubResourcePatch(subResourcePatchOptions *client.SubResourcePatchOptions) {
	_mock.Called(subResourcePatchOptions)
	return
}

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

// ApplyToSubResourcePatch is a helper method to define mock.On call
//   - subResourcePatchOptions *client.SubResourcePatchOptions
func (_e *SubResourcePatchOption_Expecter) ApplyToSubResourcePatch(subResourcePatchOptions interface{}) *SubResourcePatchOption_ApplyToSubResourcePatch_Call {
	return &SubResourcePatchOption_ApplyToSubResourcePatch_Call{Call: _e.mock.On("ApplyToSubResourcePatch", subResourcePatchOptions)}
}

func (_c *SubResourcePatchOption_ApplyToSubResourcePatch_Call) Run(run func(subResourcePatchOptions *client.SubResourcePatchOptions)) *SubResourcePatchOption_ApplyToSubResourcePatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.SubResourcePatchOptions
		if args[0] != nil {
			arg0 = args[0].(*client.SubResourcePatchOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SubResourcePatchOption_ApplyToSubResourcePatch_Call) Return() *SubResourcePatchOption_ApplyToSubResourcePatch_Call {
	_c.Call.Return()
	return _c
}

func (_c *SubResourcePatchOption_ApplyToSubResourcePatch_Call) RunAndReturn(run func(subResourcePatchOptions *client.SubResourcePatchOptions)) *SubResourcePatchOption_ApplyToSubResourcePatch_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

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

type MergeFromOption_Expecter struct {
	mock *mock.Mock
}

func (_m *MergeFromOption) EXPECT() *MergeFromOption_Expecter {
	return &MergeFromOption_Expecter{mock: &_m.Mock}
}

// ApplyToMergeFrom provides a mock function for the type MergeFromOption
func (_mock *MergeFromOption) ApplyToMergeFrom(mergeFromOptions *client.MergeFromOptions) {
	_mock.Called(mergeFromOptions)
	return
}

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

// ApplyToMergeFrom is a helper method to define mock.On call
//   - mergeFromOptions *client.MergeFromOptions
func (_e *MergeFromOption_Expecter) ApplyToMergeFrom(mergeFromOptions interface{}) *MergeFromOption_ApplyToMergeFrom_Call {
	return &MergeFromOption_ApplyToMergeFrom_Call{Call: _e.mock.On("ApplyToMergeFrom", mergeFromOptions)}
}

func (_c *MergeFromOption_ApplyToMergeFrom_Call) Run(run func(mergeFromOptions *client.MergeFromOptions)) *MergeFromOption_ApplyToMergeFrom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *client.MergeFromOptions
		if args[0] != nil {
			arg0 = args[0].(*client.MergeFromOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MergeFromOption_ApplyToMergeFrom_Call) Return() *MergeFromOption_ApplyToMergeFrom_Call {
	_c.Call.Return()
	return _c
}

func (_c *MergeFromOption_ApplyToMergeFrom_Call) RunAndReturn(run func(mergeFromOptions *client.MergeFromOptions)) *MergeFromOption_ApplyToMergeFrom_Call {
	_c.Run(run)
	return _c
}