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

package mocks

import (
	"context"

	"github.com/argoproj/argo-cd/v3/controller/hydrator/types"
	"github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
	"github.com/argoproj/argo-cd/v3/reposerver/apiclient"
	mock "github.com/stretchr/testify/mock"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)

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

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

	return mock
}

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

type Dependencies_Expecter struct {
	mock *mock.Mock
}

func (_m *Dependencies) EXPECT() *Dependencies_Expecter {
	return &Dependencies_Expecter{mock: &_m.Mock}
}

// AddHydrationQueueItem provides a mock function for the type Dependencies
func (_mock *Dependencies) AddHydrationQueueItem(key types.HydrationQueueKey) {
	_mock.Called(key)
	return
}

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

// AddHydrationQueueItem is a helper method to define mock.On call
//   - key types.HydrationQueueKey
func (_e *Dependencies_Expecter) AddHydrationQueueItem(key any) *Dependencies_AddHydrationQueueItem_Call {
	return &Dependencies_AddHydrationQueueItem_Call{Call: _e.mock.On("AddHydrationQueueItem", key)}
}

func (_c *Dependencies_AddHydrationQueueItem_Call) Run(run func(key types.HydrationQueueKey)) *Dependencies_AddHydrationQueueItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 types.HydrationQueueKey
		if args[0] != nil {
			arg0 = args[0].(types.HydrationQueueKey)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *Dependencies_AddHydrationQueueItem_Call) RunAndReturn(run func(key types.HydrationQueueKey)) *Dependencies_AddHydrationQueueItem_Call {
	_c.Run(run)
	return _c
}

// EvaluateAppRevisionsChanges provides a mock function for the type Dependencies
func (_mock *Dependencies) EvaluateAppRevisionsChanges(ctx context.Context, app *v1alpha1.Application, source v1alpha1.ApplicationSource, revision string, project *v1alpha1.AppProject, noRevisionCache bool) (bool, string, error) {
	ret := _mock.Called(ctx, app, source, revision, project, noRevisionCache)

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

	var r0 bool
	var r1 string
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject, bool) (bool, string, error)); ok {
		return returnFunc(ctx, app, source, revision, project, noRevisionCache)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject, bool) bool); ok {
		r0 = returnFunc(ctx, app, source, revision, project, noRevisionCache)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject, bool) string); ok {
		r1 = returnFunc(ctx, app, source, revision, project, noRevisionCache)
	} else {
		r1 = ret.Get(1).(string)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject, bool) error); ok {
		r2 = returnFunc(ctx, app, source, revision, project, noRevisionCache)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// EvaluateAppRevisionsChanges is a helper method to define mock.On call
//   - ctx context.Context
//   - app *v1alpha1.Application
//   - source v1alpha1.ApplicationSource
//   - revision string
//   - project *v1alpha1.AppProject
//   - noRevisionCache bool
func (_e *Dependencies_Expecter) EvaluateAppRevisionsChanges(ctx any, app any, source any, revision any, project any, noRevisionCache any) *Dependencies_EvaluateAppRevisionsChanges_Call {
	return &Dependencies_EvaluateAppRevisionsChanges_Call{Call: _e.mock.On("EvaluateAppRevisionsChanges", ctx, app, source, revision, project, noRevisionCache)}
}

func (_c *Dependencies_EvaluateAppRevisionsChanges_Call) Run(run func(ctx context.Context, app *v1alpha1.Application, source v1alpha1.ApplicationSource, revision string, project *v1alpha1.AppProject, noRevisionCache bool)) *Dependencies_EvaluateAppRevisionsChanges_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *v1alpha1.Application
		if args[1] != nil {
			arg1 = args[1].(*v1alpha1.Application)
		}
		var arg2 v1alpha1.ApplicationSource
		if args[2] != nil {
			arg2 = args[2].(v1alpha1.ApplicationSource)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 *v1alpha1.AppProject
		if args[4] != nil {
			arg4 = args[4].(*v1alpha1.AppProject)
		}
		var arg5 bool
		if args[5] != nil {
			arg5 = args[5].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

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

func (_c *Dependencies_EvaluateAppRevisionsChanges_Call) RunAndReturn(run func(ctx context.Context, app *v1alpha1.Application, source v1alpha1.ApplicationSource, revision string, project *v1alpha1.AppProject, noRevisionCache bool) (bool, string, error)) *Dependencies_EvaluateAppRevisionsChanges_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommitAuthorEmail provides a mock function for the type Dependencies
func (_mock *Dependencies) GetCommitAuthorEmail() (string, error) {
	ret := _mock.Called()

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

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

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

// GetCommitAuthorEmail is a helper method to define mock.On call
func (_e *Dependencies_Expecter) GetCommitAuthorEmail() *Dependencies_GetCommitAuthorEmail_Call {
	return &Dependencies_GetCommitAuthorEmail_Call{Call: _e.mock.On("GetCommitAuthorEmail")}
}

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

func (_c *Dependencies_GetCommitAuthorEmail_Call) Return(s string, err error) *Dependencies_GetCommitAuthorEmail_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *Dependencies_GetCommitAuthorEmail_Call) RunAndReturn(run func() (string, error)) *Dependencies_GetCommitAuthorEmail_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommitAuthorName provides a mock function for the type Dependencies
func (_mock *Dependencies) GetCommitAuthorName() (string, error) {
	ret := _mock.Called()

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

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

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

// GetCommitAuthorName is a helper method to define mock.On call
func (_e *Dependencies_Expecter) GetCommitAuthorName() *Dependencies_GetCommitAuthorName_Call {
	return &Dependencies_GetCommitAuthorName_Call{Call: _e.mock.On("GetCommitAuthorName")}
}

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

func (_c *Dependencies_GetCommitAuthorName_Call) Return(s string, err error) *Dependencies_GetCommitAuthorName_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *Dependencies_GetCommitAuthorName_Call) RunAndReturn(run func() (string, error)) *Dependencies_GetCommitAuthorName_Call {
	_c.Call.Return(run)
	return _c
}

// GetHydratorCommitMessageTemplate provides a mock function for the type Dependencies
func (_mock *Dependencies) GetHydratorCommitMessageTemplate() (string, error) {
	ret := _mock.Called()

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

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

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

// GetHydratorCommitMessageTemplate is a helper method to define mock.On call
func (_e *Dependencies_Expecter) GetHydratorCommitMessageTemplate() *Dependencies_GetHydratorCommitMessageTemplate_Call {
	return &Dependencies_GetHydratorCommitMessageTemplate_Call{Call: _e.mock.On("GetHydratorCommitMessageTemplate")}
}

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

func (_c *Dependencies_GetHydratorCommitMessageTemplate_Call) Return(s string, err error) *Dependencies_GetHydratorCommitMessageTemplate_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *Dependencies_GetHydratorCommitMessageTemplate_Call) RunAndReturn(run func() (string, error)) *Dependencies_GetHydratorCommitMessageTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetHydratorReadmeMessageTemplate provides a mock function for the type Dependencies
func (_mock *Dependencies) GetHydratorReadmeMessageTemplate() (string, error) {
	ret := _mock.Called()

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

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

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

// GetHydratorReadmeMessageTemplate is a helper method to define mock.On call
func (_e *Dependencies_Expecter) GetHydratorReadmeMessageTemplate() *Dependencies_GetHydratorReadmeMessageTemplate_Call {
	return &Dependencies_GetHydratorReadmeMessageTemplate_Call{Call: _e.mock.On("GetHydratorReadmeMessageTemplate")}
}

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

func (_c *Dependencies_GetHydratorReadmeMessageTemplate_Call) Return(s string, err error) *Dependencies_GetHydratorReadmeMessageTemplate_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *Dependencies_GetHydratorReadmeMessageTemplate_Call) RunAndReturn(run func() (string, error)) *Dependencies_GetHydratorReadmeMessageTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetProcessableAppProj provides a mock function for the type Dependencies
func (_mock *Dependencies) GetProcessableAppProj(app *v1alpha1.Application) (*v1alpha1.AppProject, error) {
	ret := _mock.Called(app)

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

	var r0 *v1alpha1.AppProject
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*v1alpha1.Application) (*v1alpha1.AppProject, error)); ok {
		return returnFunc(app)
	}
	if returnFunc, ok := ret.Get(0).(func(*v1alpha1.Application) *v1alpha1.AppProject); ok {
		r0 = returnFunc(app)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.AppProject)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*v1alpha1.Application) error); ok {
		r1 = returnFunc(app)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProcessableAppProj is a helper method to define mock.On call
//   - app *v1alpha1.Application
func (_e *Dependencies_Expecter) GetProcessableAppProj(app any) *Dependencies_GetProcessableAppProj_Call {
	return &Dependencies_GetProcessableAppProj_Call{Call: _e.mock.On("GetProcessableAppProj", app)}
}

func (_c *Dependencies_GetProcessableAppProj_Call) Run(run func(app *v1alpha1.Application)) *Dependencies_GetProcessableAppProj_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *v1alpha1.Application
		if args[0] != nil {
			arg0 = args[0].(*v1alpha1.Application)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Dependencies_GetProcessableAppProj_Call) Return(appProject *v1alpha1.AppProject, err error) *Dependencies_GetProcessableAppProj_Call {
	_c.Call.Return(appProject, err)
	return _c
}

func (_c *Dependencies_GetProcessableAppProj_Call) RunAndReturn(run func(app *v1alpha1.Application) (*v1alpha1.AppProject, error)) *Dependencies_GetProcessableAppProj_Call {
	_c.Call.Return(run)
	return _c
}

// GetProcessableApps provides a mock function for the type Dependencies
func (_mock *Dependencies) GetProcessableApps() (*v1alpha1.ApplicationList, error) {
	ret := _mock.Called()

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

	var r0 *v1alpha1.ApplicationList
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (*v1alpha1.ApplicationList, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() *v1alpha1.ApplicationList); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.ApplicationList)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProcessableApps is a helper method to define mock.On call
func (_e *Dependencies_Expecter) GetProcessableApps() *Dependencies_GetProcessableApps_Call {
	return &Dependencies_GetProcessableApps_Call{Call: _e.mock.On("GetProcessableApps")}
}

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

func (_c *Dependencies_GetProcessableApps_Call) Return(applicationList *v1alpha1.ApplicationList, err error) *Dependencies_GetProcessableApps_Call {
	_c.Call.Return(applicationList, err)
	return _c
}

func (_c *Dependencies_GetProcessableApps_Call) RunAndReturn(run func() (*v1alpha1.ApplicationList, error)) *Dependencies_GetProcessableApps_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepoObjs provides a mock function for the type Dependencies
func (_mock *Dependencies) GetRepoObjs(ctx context.Context, app *v1alpha1.Application, source v1alpha1.ApplicationSource, revision string, project *v1alpha1.AppProject) ([]*unstructured.Unstructured, *apiclient.ManifestResponse, error) {
	ret := _mock.Called(ctx, app, source, revision, project)

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

	var r0 []*unstructured.Unstructured
	var r1 *apiclient.ManifestResponse
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject) ([]*unstructured.Unstructured, *apiclient.ManifestResponse, error)); ok {
		return returnFunc(ctx, app, source, revision, project)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject) []*unstructured.Unstructured); ok {
		r0 = returnFunc(ctx, app, source, revision, project)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*unstructured.Unstructured)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject) *apiclient.ManifestResponse); ok {
		r1 = returnFunc(ctx, app, source, revision, project)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*apiclient.ManifestResponse)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, *v1alpha1.Application, v1alpha1.ApplicationSource, string, *v1alpha1.AppProject) error); ok {
		r2 = returnFunc(ctx, app, source, revision, project)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetRepoObjs is a helper method to define mock.On call
//   - ctx context.Context
//   - app *v1alpha1.Application
//   - source v1alpha1.ApplicationSource
//   - revision string
//   - project *v1alpha1.AppProject
func (_e *Dependencies_Expecter) GetRepoObjs(ctx any, app any, source any, revision any, project any) *Dependencies_GetRepoObjs_Call {
	return &Dependencies_GetRepoObjs_Call{Call: _e.mock.On("GetRepoObjs", ctx, app, source, revision, project)}
}

func (_c *Dependencies_GetRepoObjs_Call) Run(run func(ctx context.Context, app *v1alpha1.Application, source v1alpha1.ApplicationSource, revision string, project *v1alpha1.AppProject)) *Dependencies_GetRepoObjs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *v1alpha1.Application
		if args[1] != nil {
			arg1 = args[1].(*v1alpha1.Application)
		}
		var arg2 v1alpha1.ApplicationSource
		if args[2] != nil {
			arg2 = args[2].(v1alpha1.ApplicationSource)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 *v1alpha1.AppProject
		if args[4] != nil {
			arg4 = args[4].(*v1alpha1.AppProject)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *Dependencies_GetRepoObjs_Call) Return(unstructureds []*unstructured.Unstructured, manifestResponse *apiclient.ManifestResponse, err error) *Dependencies_GetRepoObjs_Call {
	_c.Call.Return(unstructureds, manifestResponse, err)
	return _c
}

func (_c *Dependencies_GetRepoObjs_Call) RunAndReturn(run func(ctx context.Context, app *v1alpha1.Application, source v1alpha1.ApplicationSource, revision string, project *v1alpha1.AppProject) ([]*unstructured.Unstructured, *apiclient.ManifestResponse, error)) *Dependencies_GetRepoObjs_Call {
	_c.Call.Return(run)
	return _c
}

// GetWriteCredentials provides a mock function for the type Dependencies
func (_mock *Dependencies) GetWriteCredentials(ctx context.Context, repoURL string, project string) (*v1alpha1.Repository, error) {
	ret := _mock.Called(ctx, repoURL, project)

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

	var r0 *v1alpha1.Repository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*v1alpha1.Repository, error)); ok {
		return returnFunc(ctx, repoURL, project)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *v1alpha1.Repository); ok {
		r0 = returnFunc(ctx, repoURL, project)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.Repository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, repoURL, project)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetWriteCredentials is a helper method to define mock.On call
//   - ctx context.Context
//   - repoURL string
//   - project string
func (_e *Dependencies_Expecter) GetWriteCredentials(ctx any, repoURL any, project any) *Dependencies_GetWriteCredentials_Call {
	return &Dependencies_GetWriteCredentials_Call{Call: _e.mock.On("GetWriteCredentials", ctx, repoURL, project)}
}

func (_c *Dependencies_GetWriteCredentials_Call) Run(run func(ctx context.Context, repoURL string, project string)) *Dependencies_GetWriteCredentials_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Dependencies_GetWriteCredentials_Call) Return(repository *v1alpha1.Repository, err error) *Dependencies_GetWriteCredentials_Call {
	_c.Call.Return(repository, err)
	return _c
}

func (_c *Dependencies_GetWriteCredentials_Call) RunAndReturn(run func(ctx context.Context, repoURL string, project string) (*v1alpha1.Repository, error)) *Dependencies_GetWriteCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// PersistHydrationStatus provides a mock function for the type Dependencies
func (_mock *Dependencies) PersistHydrationStatus(orig *v1alpha1.Application, newStatus *v1alpha1.SourceHydratorStatus) {
	_mock.Called(orig, newStatus)
	return
}

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

// PersistHydrationStatus is a helper method to define mock.On call
//   - orig *v1alpha1.Application
//   - newStatus *v1alpha1.SourceHydratorStatus
func (_e *Dependencies_Expecter) PersistHydrationStatus(orig any, newStatus any) *Dependencies_PersistHydrationStatus_Call {
	return &Dependencies_PersistHydrationStatus_Call{Call: _e.mock.On("PersistHydrationStatus", orig, newStatus)}
}

func (_c *Dependencies_PersistHydrationStatus_Call) Run(run func(orig *v1alpha1.Application, newStatus *v1alpha1.SourceHydratorStatus)) *Dependencies_PersistHydrationStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *v1alpha1.Application
		if args[0] != nil {
			arg0 = args[0].(*v1alpha1.Application)
		}
		var arg1 *v1alpha1.SourceHydratorStatus
		if args[1] != nil {
			arg1 = args[1].(*v1alpha1.SourceHydratorStatus)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *Dependencies_PersistHydrationStatus_Call) RunAndReturn(run func(orig *v1alpha1.Application, newStatus *v1alpha1.SourceHydratorStatus)) *Dependencies_PersistHydrationStatus_Call {
	_c.Run(run)
	return _c
}

// RequestAppRefresh provides a mock function for the type Dependencies
func (_mock *Dependencies) RequestAppRefresh(appName string, appNamespace string) error {
	ret := _mock.Called(appName, appNamespace)

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

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

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

// RequestAppRefresh is a helper method to define mock.On call
//   - appName string
//   - appNamespace string
func (_e *Dependencies_Expecter) RequestAppRefresh(appName any, appNamespace any) *Dependencies_RequestAppRefresh_Call {
	return &Dependencies_RequestAppRefresh_Call{Call: _e.mock.On("RequestAppRefresh", appName, appNamespace)}
}

func (_c *Dependencies_RequestAppRefresh_Call) Run(run func(appName string, appNamespace string)) *Dependencies_RequestAppRefresh_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *Dependencies_RequestAppRefresh_Call) RunAndReturn(run func(appName string, appNamespace string) error) *Dependencies_RequestAppRefresh_Call {
	_c.Call.Return(run)
	return _c
}
