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

package mocks

import (
	"context"

	mock "github.com/stretchr/testify/mock"
	"go.woodpecker-ci.org/woodpecker/v3/server/model"
)

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

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

	return mock
}

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

type MockService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockService) EXPECT() *MockService_Expecter {
	return &MockService_Expecter{mock: &_m.Mock}
}

// GlobalSecretCreate provides a mock function for the type MockService
func (_mock *MockService) GlobalSecretCreate(secret *model.Secret) error {
	ret := _mock.Called(secret)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(*model.Secret) error); ok {
		r0 = returnFunc(secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// GlobalSecretCreate is a helper method to define mock.On call
//   - secret *model.Secret
func (_e *MockService_Expecter) GlobalSecretCreate(secret interface{}) *MockService_GlobalSecretCreate_Call {
	return &MockService_GlobalSecretCreate_Call{Call: _e.mock.On("GlobalSecretCreate", secret)}
}

func (_c *MockService_GlobalSecretCreate_Call) Run(run func(secret *model.Secret)) *MockService_GlobalSecretCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Secret
		if args[0] != nil {
			arg0 = args[0].(*model.Secret)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockService_GlobalSecretCreate_Call) RunAndReturn(run func(secret *model.Secret) error) *MockService_GlobalSecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecretDelete provides a mock function for the type MockService
func (_mock *MockService) GlobalSecretDelete(s string) error {
	ret := _mock.Called(s)

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

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

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

// GlobalSecretDelete is a helper method to define mock.On call
//   - s string
func (_e *MockService_Expecter) GlobalSecretDelete(s interface{}) *MockService_GlobalSecretDelete_Call {
	return &MockService_GlobalSecretDelete_Call{Call: _e.mock.On("GlobalSecretDelete", s)}
}

func (_c *MockService_GlobalSecretDelete_Call) Run(run func(s string)) *MockService_GlobalSecretDelete_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 *MockService_GlobalSecretDelete_Call) Return(err error) *MockService_GlobalSecretDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockService_GlobalSecretDelete_Call) RunAndReturn(run func(s string) error) *MockService_GlobalSecretDelete_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecretFind provides a mock function for the type MockService
func (_mock *MockService) GlobalSecretFind(s string) (*model.Secret, error) {
	ret := _mock.Called(s)

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

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

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

// GlobalSecretFind is a helper method to define mock.On call
//   - s string
func (_e *MockService_Expecter) GlobalSecretFind(s interface{}) *MockService_GlobalSecretFind_Call {
	return &MockService_GlobalSecretFind_Call{Call: _e.mock.On("GlobalSecretFind", s)}
}

func (_c *MockService_GlobalSecretFind_Call) Run(run func(s string)) *MockService_GlobalSecretFind_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 *MockService_GlobalSecretFind_Call) Return(secret *model.Secret, err error) *MockService_GlobalSecretFind_Call {
	_c.Call.Return(secret, err)
	return _c
}

func (_c *MockService_GlobalSecretFind_Call) RunAndReturn(run func(s string) (*model.Secret, error)) *MockService_GlobalSecretFind_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecretList provides a mock function for the type MockService
func (_mock *MockService) GlobalSecretList(listOptions *model.ListOptions) ([]*model.Secret, error) {
	ret := _mock.Called(listOptions)

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

	var r0 []*model.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Secret, error)); ok {
		return returnFunc(listOptions)
	}
	if returnFunc, ok := ret.Get(0).(func(*model.ListOptions) []*model.Secret); ok {
		r0 = returnFunc(listOptions)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = returnFunc(listOptions)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GlobalSecretList is a helper method to define mock.On call
//   - listOptions *model.ListOptions
func (_e *MockService_Expecter) GlobalSecretList(listOptions interface{}) *MockService_GlobalSecretList_Call {
	return &MockService_GlobalSecretList_Call{Call: _e.mock.On("GlobalSecretList", listOptions)}
}

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

func (_c *MockService_GlobalSecretList_Call) Return(secrets []*model.Secret, err error) *MockService_GlobalSecretList_Call {
	_c.Call.Return(secrets, err)
	return _c
}

func (_c *MockService_GlobalSecretList_Call) RunAndReturn(run func(listOptions *model.ListOptions) ([]*model.Secret, error)) *MockService_GlobalSecretList_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecretUpdate provides a mock function for the type MockService
func (_mock *MockService) GlobalSecretUpdate(secret *model.Secret) error {
	ret := _mock.Called(secret)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(*model.Secret) error); ok {
		r0 = returnFunc(secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// GlobalSecretUpdate is a helper method to define mock.On call
//   - secret *model.Secret
func (_e *MockService_Expecter) GlobalSecretUpdate(secret interface{}) *MockService_GlobalSecretUpdate_Call {
	return &MockService_GlobalSecretUpdate_Call{Call: _e.mock.On("GlobalSecretUpdate", secret)}
}

func (_c *MockService_GlobalSecretUpdate_Call) Run(run func(secret *model.Secret)) *MockService_GlobalSecretUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Secret
		if args[0] != nil {
			arg0 = args[0].(*model.Secret)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockService_GlobalSecretUpdate_Call) RunAndReturn(run func(secret *model.Secret) error) *MockService_GlobalSecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretCreate provides a mock function for the type MockService
func (_mock *MockService) OrgSecretCreate(n int64, secret *model.Secret) error {
	ret := _mock.Called(n, secret)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int64, *model.Secret) error); ok {
		r0 = returnFunc(n, secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrgSecretCreate is a helper method to define mock.On call
//   - n int64
//   - secret *model.Secret
func (_e *MockService_Expecter) OrgSecretCreate(n interface{}, secret interface{}) *MockService_OrgSecretCreate_Call {
	return &MockService_OrgSecretCreate_Call{Call: _e.mock.On("OrgSecretCreate", n, secret)}
}

func (_c *MockService_OrgSecretCreate_Call) Run(run func(n int64, secret *model.Secret)) *MockService_OrgSecretCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *model.Secret
		if args[1] != nil {
			arg1 = args[1].(*model.Secret)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockService_OrgSecretCreate_Call) RunAndReturn(run func(n int64, secret *model.Secret) error) *MockService_OrgSecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretDelete provides a mock function for the type MockService
func (_mock *MockService) OrgSecretDelete(n int64, s string) error {
	ret := _mock.Called(n, s)

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

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

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

// OrgSecretDelete is a helper method to define mock.On call
//   - n int64
//   - s string
func (_e *MockService_Expecter) OrgSecretDelete(n interface{}, s interface{}) *MockService_OrgSecretDelete_Call {
	return &MockService_OrgSecretDelete_Call{Call: _e.mock.On("OrgSecretDelete", n, s)}
}

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

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

func (_c *MockService_OrgSecretDelete_Call) RunAndReturn(run func(n int64, s string) error) *MockService_OrgSecretDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretFind provides a mock function for the type MockService
func (_mock *MockService) OrgSecretFind(n int64, s string) (*model.Secret, error) {
	ret := _mock.Called(n, s)

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

	var r0 *model.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, string) (*model.Secret, error)); ok {
		return returnFunc(n, s)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, string) *model.Secret); ok {
		r0 = returnFunc(n, s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = returnFunc(n, s)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgSecretFind is a helper method to define mock.On call
//   - n int64
//   - s string
func (_e *MockService_Expecter) OrgSecretFind(n interface{}, s interface{}) *MockService_OrgSecretFind_Call {
	return &MockService_OrgSecretFind_Call{Call: _e.mock.On("OrgSecretFind", n, s)}
}

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

func (_c *MockService_OrgSecretFind_Call) Return(secret *model.Secret, err error) *MockService_OrgSecretFind_Call {
	_c.Call.Return(secret, err)
	return _c
}

func (_c *MockService_OrgSecretFind_Call) RunAndReturn(run func(n int64, s string) (*model.Secret, error)) *MockService_OrgSecretFind_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretList provides a mock function for the type MockService
func (_mock *MockService) OrgSecretList(n int64, listOptions *model.ListOptions) ([]*model.Secret, error) {
	ret := _mock.Called(n, listOptions)

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

	var r0 []*model.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Secret, error)); ok {
		return returnFunc(n, listOptions)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Secret); ok {
		r0 = returnFunc(n, listOptions)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
		r1 = returnFunc(n, listOptions)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgSecretList is a helper method to define mock.On call
//   - n int64
//   - listOptions *model.ListOptions
func (_e *MockService_Expecter) OrgSecretList(n interface{}, listOptions interface{}) *MockService_OrgSecretList_Call {
	return &MockService_OrgSecretList_Call{Call: _e.mock.On("OrgSecretList", n, listOptions)}
}

func (_c *MockService_OrgSecretList_Call) Run(run func(n int64, listOptions *model.ListOptions)) *MockService_OrgSecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *model.ListOptions
		if args[1] != nil {
			arg1 = args[1].(*model.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_OrgSecretList_Call) Return(secrets []*model.Secret, err error) *MockService_OrgSecretList_Call {
	_c.Call.Return(secrets, err)
	return _c
}

func (_c *MockService_OrgSecretList_Call) RunAndReturn(run func(n int64, listOptions *model.ListOptions) ([]*model.Secret, error)) *MockService_OrgSecretList_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretUpdate provides a mock function for the type MockService
func (_mock *MockService) OrgSecretUpdate(n int64, secret *model.Secret) error {
	ret := _mock.Called(n, secret)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int64, *model.Secret) error); ok {
		r0 = returnFunc(n, secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrgSecretUpdate is a helper method to define mock.On call
//   - n int64
//   - secret *model.Secret
func (_e *MockService_Expecter) OrgSecretUpdate(n interface{}, secret interface{}) *MockService_OrgSecretUpdate_Call {
	return &MockService_OrgSecretUpdate_Call{Call: _e.mock.On("OrgSecretUpdate", n, secret)}
}

func (_c *MockService_OrgSecretUpdate_Call) Run(run func(n int64, secret *model.Secret)) *MockService_OrgSecretUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *model.Secret
		if args[1] != nil {
			arg1 = args[1].(*model.Secret)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockService_OrgSecretUpdate_Call) RunAndReturn(run func(n int64, secret *model.Secret) error) *MockService_OrgSecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// SecretCreate provides a mock function for the type MockService
func (_mock *MockService) SecretCreate(repo *model.Repo, secret *model.Secret) error {
	ret := _mock.Called(repo, secret)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Secret) error); ok {
		r0 = returnFunc(repo, secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SecretCreate is a helper method to define mock.On call
//   - repo *model.Repo
//   - secret *model.Secret
func (_e *MockService_Expecter) SecretCreate(repo interface{}, secret interface{}) *MockService_SecretCreate_Call {
	return &MockService_SecretCreate_Call{Call: _e.mock.On("SecretCreate", repo, secret)}
}

func (_c *MockService_SecretCreate_Call) Run(run func(repo *model.Repo, secret *model.Secret)) *MockService_SecretCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Repo
		if args[0] != nil {
			arg0 = args[0].(*model.Repo)
		}
		var arg1 *model.Secret
		if args[1] != nil {
			arg1 = args[1].(*model.Secret)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockService_SecretCreate_Call) RunAndReturn(run func(repo *model.Repo, secret *model.Secret) error) *MockService_SecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

// SecretDelete provides a mock function for the type MockService
func (_mock *MockService) SecretDelete(repo *model.Repo, s string) error {
	ret := _mock.Called(repo, s)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) error); ok {
		r0 = returnFunc(repo, s)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SecretDelete is a helper method to define mock.On call
//   - repo *model.Repo
//   - s string
func (_e *MockService_Expecter) SecretDelete(repo interface{}, s interface{}) *MockService_SecretDelete_Call {
	return &MockService_SecretDelete_Call{Call: _e.mock.On("SecretDelete", repo, s)}
}

func (_c *MockService_SecretDelete_Call) Run(run func(repo *model.Repo, s string)) *MockService_SecretDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Repo
		if args[0] != nil {
			arg0 = args[0].(*model.Repo)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockService_SecretDelete_Call) RunAndReturn(run func(repo *model.Repo, s string) error) *MockService_SecretDelete_Call {
	_c.Call.Return(run)
	return _c
}

// SecretFind provides a mock function for the type MockService
func (_mock *MockService) SecretFind(repo *model.Repo, s string) (*model.Secret, error) {
	ret := _mock.Called(repo, s)

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

	var r0 *model.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) (*model.Secret, error)); ok {
		return returnFunc(repo, s)
	}
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, string) *model.Secret); ok {
		r0 = returnFunc(repo, s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
		r1 = returnFunc(repo, s)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SecretFind is a helper method to define mock.On call
//   - repo *model.Repo
//   - s string
func (_e *MockService_Expecter) SecretFind(repo interface{}, s interface{}) *MockService_SecretFind_Call {
	return &MockService_SecretFind_Call{Call: _e.mock.On("SecretFind", repo, s)}
}

func (_c *MockService_SecretFind_Call) Run(run func(repo *model.Repo, s string)) *MockService_SecretFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Repo
		if args[0] != nil {
			arg0 = args[0].(*model.Repo)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_SecretFind_Call) Return(secret *model.Secret, err error) *MockService_SecretFind_Call {
	_c.Call.Return(secret, err)
	return _c
}

func (_c *MockService_SecretFind_Call) RunAndReturn(run func(repo *model.Repo, s string) (*model.Secret, error)) *MockService_SecretFind_Call {
	_c.Call.Return(run)
	return _c
}

// SecretList provides a mock function for the type MockService
func (_mock *MockService) SecretList(repo *model.Repo, listOptions *model.ListOptions) ([]*model.Secret, error) {
	ret := _mock.Called(repo, listOptions)

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

	var r0 []*model.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Secret, error)); ok {
		return returnFunc(repo, listOptions)
	}
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Secret); ok {
		r0 = returnFunc(repo, listOptions)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
		r1 = returnFunc(repo, listOptions)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SecretList is a helper method to define mock.On call
//   - repo *model.Repo
//   - listOptions *model.ListOptions
func (_e *MockService_Expecter) SecretList(repo interface{}, listOptions interface{}) *MockService_SecretList_Call {
	return &MockService_SecretList_Call{Call: _e.mock.On("SecretList", repo, listOptions)}
}

func (_c *MockService_SecretList_Call) Run(run func(repo *model.Repo, listOptions *model.ListOptions)) *MockService_SecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Repo
		if args[0] != nil {
			arg0 = args[0].(*model.Repo)
		}
		var arg1 *model.ListOptions
		if args[1] != nil {
			arg1 = args[1].(*model.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_SecretList_Call) Return(secrets []*model.Secret, err error) *MockService_SecretList_Call {
	_c.Call.Return(secrets, err)
	return _c
}

func (_c *MockService_SecretList_Call) RunAndReturn(run func(repo *model.Repo, listOptions *model.ListOptions) ([]*model.Secret, error)) *MockService_SecretList_Call {
	_c.Call.Return(run)
	return _c
}

// SecretListPipeline provides a mock function for the type MockService
func (_mock *MockService) SecretListPipeline(context1 context.Context, repo *model.Repo, pipeline *model.Pipeline, netrc *model.Netrc) ([]*model.Secret, error) {
	ret := _mock.Called(context1, repo, pipeline, netrc)

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

	var r0 []*model.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *model.Repo, *model.Pipeline, *model.Netrc) ([]*model.Secret, error)); ok {
		return returnFunc(context1, repo, pipeline, netrc)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *model.Repo, *model.Pipeline, *model.Netrc) []*model.Secret); ok {
		r0 = returnFunc(context1, repo, pipeline, netrc)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *model.Repo, *model.Pipeline, *model.Netrc) error); ok {
		r1 = returnFunc(context1, repo, pipeline, netrc)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SecretListPipeline is a helper method to define mock.On call
//   - context1 context.Context
//   - repo *model.Repo
//   - pipeline *model.Pipeline
//   - netrc *model.Netrc
func (_e *MockService_Expecter) SecretListPipeline(context1 interface{}, repo interface{}, pipeline interface{}, netrc interface{}) *MockService_SecretListPipeline_Call {
	return &MockService_SecretListPipeline_Call{Call: _e.mock.On("SecretListPipeline", context1, repo, pipeline, netrc)}
}

func (_c *MockService_SecretListPipeline_Call) Run(run func(context1 context.Context, repo *model.Repo, pipeline *model.Pipeline, netrc *model.Netrc)) *MockService_SecretListPipeline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *model.Repo
		if args[1] != nil {
			arg1 = args[1].(*model.Repo)
		}
		var arg2 *model.Pipeline
		if args[2] != nil {
			arg2 = args[2].(*model.Pipeline)
		}
		var arg3 *model.Netrc
		if args[3] != nil {
			arg3 = args[3].(*model.Netrc)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockService_SecretListPipeline_Call) Return(secrets []*model.Secret, err error) *MockService_SecretListPipeline_Call {
	_c.Call.Return(secrets, err)
	return _c
}

func (_c *MockService_SecretListPipeline_Call) RunAndReturn(run func(context1 context.Context, repo *model.Repo, pipeline *model.Pipeline, netrc *model.Netrc) ([]*model.Secret, error)) *MockService_SecretListPipeline_Call {
	_c.Call.Return(run)
	return _c
}

// SecretUpdate provides a mock function for the type MockService
func (_mock *MockService) SecretUpdate(repo *model.Repo, secret *model.Secret) error {
	ret := _mock.Called(repo, secret)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(*model.Repo, *model.Secret) error); ok {
		r0 = returnFunc(repo, secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SecretUpdate is a helper method to define mock.On call
//   - repo *model.Repo
//   - secret *model.Secret
func (_e *MockService_Expecter) SecretUpdate(repo interface{}, secret interface{}) *MockService_SecretUpdate_Call {
	return &MockService_SecretUpdate_Call{Call: _e.mock.On("SecretUpdate", repo, secret)}
}

func (_c *MockService_SecretUpdate_Call) Run(run func(repo *model.Repo, secret *model.Secret)) *MockService_SecretUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *model.Repo
		if args[0] != nil {
			arg0 = args[0].(*model.Repo)
		}
		var arg1 *model.Secret
		if args[1] != nil {
			arg1 = args[1].(*model.Secret)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockService_SecretUpdate_Call) RunAndReturn(run func(repo *model.Repo, secret *model.Secret) error) *MockService_SecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}
