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

package mocks

import (
	"net/http"

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

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

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

	return mock
}

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

type MockClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClient) EXPECT() *MockClient_Expecter {
	return &MockClient_Expecter{mock: &_m.Mock}
}

// Agent provides a mock function for the type MockClient
func (_mock *MockClient) Agent(n int64) (*woodpecker.Agent, error) {
	ret := _mock.Called(n)

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

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

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

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

func (_c *MockClient_Agent_Call) Run(run func(n int64)) *MockClient_Agent_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 *MockClient_Agent_Call) Return(agent *woodpecker.Agent, err error) *MockClient_Agent_Call {
	_c.Call.Return(agent, err)
	return _c
}

func (_c *MockClient_Agent_Call) RunAndReturn(run func(n int64) (*woodpecker.Agent, error)) *MockClient_Agent_Call {
	_c.Call.Return(run)
	return _c
}

// AgentCreate provides a mock function for the type MockClient
func (_mock *MockClient) AgentCreate(agent *woodpecker.Agent) (*woodpecker.Agent, error) {
	ret := _mock.Called(agent)

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

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

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

// AgentCreate is a helper method to define mock.On call
//   - agent *woodpecker.Agent
func (_e *MockClient_Expecter) AgentCreate(agent interface{}) *MockClient_AgentCreate_Call {
	return &MockClient_AgentCreate_Call{Call: _e.mock.On("AgentCreate", agent)}
}

func (_c *MockClient_AgentCreate_Call) Run(run func(agent *woodpecker.Agent)) *MockClient_AgentCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.Agent
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.Agent)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_AgentCreate_Call) Return(agent1 *woodpecker.Agent, err error) *MockClient_AgentCreate_Call {
	_c.Call.Return(agent1, err)
	return _c
}

func (_c *MockClient_AgentCreate_Call) RunAndReturn(run func(agent *woodpecker.Agent) (*woodpecker.Agent, error)) *MockClient_AgentCreate_Call {
	_c.Call.Return(run)
	return _c
}

// AgentDelete provides a mock function for the type MockClient
func (_mock *MockClient) AgentDelete(n int64) error {
	ret := _mock.Called(n)

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

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

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

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

func (_c *MockClient_AgentDelete_Call) Run(run func(n int64)) *MockClient_AgentDelete_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 *MockClient_AgentDelete_Call) Return(err error) *MockClient_AgentDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AgentDelete_Call) RunAndReturn(run func(n int64) error) *MockClient_AgentDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AgentList provides a mock function for the type MockClient
func (_mock *MockClient) AgentList() ([]*woodpecker.Agent, error) {
	ret := _mock.Called()

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

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

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

// AgentList is a helper method to define mock.On call
func (_e *MockClient_Expecter) AgentList() *MockClient_AgentList_Call {
	return &MockClient_AgentList_Call{Call: _e.mock.On("AgentList")}
}

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

func (_c *MockClient_AgentList_Call) Return(agents []*woodpecker.Agent, err error) *MockClient_AgentList_Call {
	_c.Call.Return(agents, err)
	return _c
}

func (_c *MockClient_AgentList_Call) RunAndReturn(run func() ([]*woodpecker.Agent, error)) *MockClient_AgentList_Call {
	_c.Call.Return(run)
	return _c
}

// AgentTasksList provides a mock function for the type MockClient
func (_mock *MockClient) AgentTasksList(n int64) ([]*woodpecker.Task, error) {
	ret := _mock.Called(n)

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

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

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

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

func (_c *MockClient_AgentTasksList_Call) Run(run func(n int64)) *MockClient_AgentTasksList_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 *MockClient_AgentTasksList_Call) Return(tasks []*woodpecker.Task, err error) *MockClient_AgentTasksList_Call {
	_c.Call.Return(tasks, err)
	return _c
}

func (_c *MockClient_AgentTasksList_Call) RunAndReturn(run func(n int64) ([]*woodpecker.Task, error)) *MockClient_AgentTasksList_Call {
	_c.Call.Return(run)
	return _c
}

// AgentUpdate provides a mock function for the type MockClient
func (_mock *MockClient) AgentUpdate(agent *woodpecker.Agent) (*woodpecker.Agent, error) {
	ret := _mock.Called(agent)

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

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

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

// AgentUpdate is a helper method to define mock.On call
//   - agent *woodpecker.Agent
func (_e *MockClient_Expecter) AgentUpdate(agent interface{}) *MockClient_AgentUpdate_Call {
	return &MockClient_AgentUpdate_Call{Call: _e.mock.On("AgentUpdate", agent)}
}

func (_c *MockClient_AgentUpdate_Call) Run(run func(agent *woodpecker.Agent)) *MockClient_AgentUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.Agent
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.Agent)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_AgentUpdate_Call) Return(agent1 *woodpecker.Agent, err error) *MockClient_AgentUpdate_Call {
	_c.Call.Return(agent1, err)
	return _c
}

func (_c *MockClient_AgentUpdate_Call) RunAndReturn(run func(agent *woodpecker.Agent) (*woodpecker.Agent, error)) *MockClient_AgentUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// CronCreate provides a mock function for the type MockClient
func (_mock *MockClient) CronCreate(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error) {
	ret := _mock.Called(repoID, cron)

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

	var r0 *woodpecker.Cron
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Cron) (*woodpecker.Cron, error)); ok {
		return returnFunc(repoID, cron)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Cron) *woodpecker.Cron); ok {
		r0 = returnFunc(repoID, cron)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Cron)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.Cron) error); ok {
		r1 = returnFunc(repoID, cron)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CronCreate is a helper method to define mock.On call
//   - repoID int64
//   - cron *woodpecker.Cron
func (_e *MockClient_Expecter) CronCreate(repoID interface{}, cron interface{}) *MockClient_CronCreate_Call {
	return &MockClient_CronCreate_Call{Call: _e.mock.On("CronCreate", repoID, cron)}
}

func (_c *MockClient_CronCreate_Call) Run(run func(repoID int64, cron *woodpecker.Cron)) *MockClient_CronCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.Cron
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.Cron)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_CronCreate_Call) Return(cron1 *woodpecker.Cron, err error) *MockClient_CronCreate_Call {
	_c.Call.Return(cron1, err)
	return _c
}

func (_c *MockClient_CronCreate_Call) RunAndReturn(run func(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error)) *MockClient_CronCreate_Call {
	_c.Call.Return(run)
	return _c
}

// CronDelete provides a mock function for the type MockClient
func (_mock *MockClient) CronDelete(repoID int64, cronID int64) error {
	ret := _mock.Called(repoID, cronID)

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

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

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

// CronDelete is a helper method to define mock.On call
//   - repoID int64
//   - cronID int64
func (_e *MockClient_Expecter) CronDelete(repoID interface{}, cronID interface{}) *MockClient_CronDelete_Call {
	return &MockClient_CronDelete_Call{Call: _e.mock.On("CronDelete", repoID, cronID)}
}

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

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

func (_c *MockClient_CronDelete_Call) RunAndReturn(run func(repoID int64, cronID int64) error) *MockClient_CronDelete_Call {
	_c.Call.Return(run)
	return _c
}

// CronGet provides a mock function for the type MockClient
func (_mock *MockClient) CronGet(repoID int64, cronID int64) (*woodpecker.Cron, error) {
	ret := _mock.Called(repoID, cronID)

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

	var r0 *woodpecker.Cron
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Cron, error)); ok {
		return returnFunc(repoID, cronID)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64) *woodpecker.Cron); ok {
		r0 = returnFunc(repoID, cronID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Cron)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64) error); ok {
		r1 = returnFunc(repoID, cronID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CronGet is a helper method to define mock.On call
//   - repoID int64
//   - cronID int64
func (_e *MockClient_Expecter) CronGet(repoID interface{}, cronID interface{}) *MockClient_CronGet_Call {
	return &MockClient_CronGet_Call{Call: _e.mock.On("CronGet", repoID, cronID)}
}

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

func (_c *MockClient_CronGet_Call) Return(cron *woodpecker.Cron, err error) *MockClient_CronGet_Call {
	_c.Call.Return(cron, err)
	return _c
}

func (_c *MockClient_CronGet_Call) RunAndReturn(run func(repoID int64, cronID int64) (*woodpecker.Cron, error)) *MockClient_CronGet_Call {
	_c.Call.Return(run)
	return _c
}

// CronList provides a mock function for the type MockClient
func (_mock *MockClient) CronList(repoID int64, opt woodpecker.CronListOptions) ([]*woodpecker.Cron, error) {
	ret := _mock.Called(repoID, opt)

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

	var r0 []*woodpecker.Cron
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.CronListOptions) ([]*woodpecker.Cron, error)); ok {
		return returnFunc(repoID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.CronListOptions) []*woodpecker.Cron); ok {
		r0 = returnFunc(repoID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Cron)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.CronListOptions) error); ok {
		r1 = returnFunc(repoID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CronList is a helper method to define mock.On call
//   - repoID int64
//   - opt woodpecker.CronListOptions
func (_e *MockClient_Expecter) CronList(repoID interface{}, opt interface{}) *MockClient_CronList_Call {
	return &MockClient_CronList_Call{Call: _e.mock.On("CronList", repoID, opt)}
}

func (_c *MockClient_CronList_Call) Run(run func(repoID int64, opt woodpecker.CronListOptions)) *MockClient_CronList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.CronListOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.CronListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_CronList_Call) Return(crons []*woodpecker.Cron, err error) *MockClient_CronList_Call {
	_c.Call.Return(crons, err)
	return _c
}

func (_c *MockClient_CronList_Call) RunAndReturn(run func(repoID int64, opt woodpecker.CronListOptions) ([]*woodpecker.Cron, error)) *MockClient_CronList_Call {
	_c.Call.Return(run)
	return _c
}

// CronUpdate provides a mock function for the type MockClient
func (_mock *MockClient) CronUpdate(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error) {
	ret := _mock.Called(repoID, cron)

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

	var r0 *woodpecker.Cron
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Cron) (*woodpecker.Cron, error)); ok {
		return returnFunc(repoID, cron)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Cron) *woodpecker.Cron); ok {
		r0 = returnFunc(repoID, cron)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Cron)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.Cron) error); ok {
		r1 = returnFunc(repoID, cron)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CronUpdate is a helper method to define mock.On call
//   - repoID int64
//   - cron *woodpecker.Cron
func (_e *MockClient_Expecter) CronUpdate(repoID interface{}, cron interface{}) *MockClient_CronUpdate_Call {
	return &MockClient_CronUpdate_Call{Call: _e.mock.On("CronUpdate", repoID, cron)}
}

func (_c *MockClient_CronUpdate_Call) Run(run func(repoID int64, cron *woodpecker.Cron)) *MockClient_CronUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.Cron
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.Cron)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_CronUpdate_Call) Return(cron1 *woodpecker.Cron, err error) *MockClient_CronUpdate_Call {
	_c.Call.Return(cron1, err)
	return _c
}

func (_c *MockClient_CronUpdate_Call) RunAndReturn(run func(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error)) *MockClient_CronUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// Deploy provides a mock function for the type MockClient
func (_mock *MockClient) Deploy(repoID int64, pipeline int64, opt woodpecker.DeployOptions) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, pipeline, opt)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64, woodpecker.DeployOptions) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, pipeline, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64, woodpecker.DeployOptions) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, pipeline, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64, woodpecker.DeployOptions) error); ok {
		r1 = returnFunc(repoID, pipeline, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Deploy is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
//   - opt woodpecker.DeployOptions
func (_e *MockClient_Expecter) Deploy(repoID interface{}, pipeline interface{}, opt interface{}) *MockClient_Deploy_Call {
	return &MockClient_Deploy_Call{Call: _e.mock.On("Deploy", repoID, pipeline, opt)}
}

func (_c *MockClient_Deploy_Call) Run(run func(repoID int64, pipeline int64, opt woodpecker.DeployOptions)) *MockClient_Deploy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 woodpecker.DeployOptions
		if args[2] != nil {
			arg2 = args[2].(woodpecker.DeployOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockClient_Deploy_Call) Return(pipeline1 *woodpecker.Pipeline, err error) *MockClient_Deploy_Call {
	_c.Call.Return(pipeline1, err)
	return _c
}

func (_c *MockClient_Deploy_Call) RunAndReturn(run func(repoID int64, pipeline int64, opt woodpecker.DeployOptions) (*woodpecker.Pipeline, error)) *MockClient_Deploy_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalRegistry provides a mock function for the type MockClient
func (_mock *MockClient) GlobalRegistry(registry string) (*woodpecker.Registry, error) {
	ret := _mock.Called(registry)

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

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

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

// GlobalRegistry is a helper method to define mock.On call
//   - registry string
func (_e *MockClient_Expecter) GlobalRegistry(registry interface{}) *MockClient_GlobalRegistry_Call {
	return &MockClient_GlobalRegistry_Call{Call: _e.mock.On("GlobalRegistry", registry)}
}

func (_c *MockClient_GlobalRegistry_Call) Run(run func(registry string)) *MockClient_GlobalRegistry_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 *MockClient_GlobalRegistry_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_GlobalRegistry_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_GlobalRegistry_Call) RunAndReturn(run func(registry string) (*woodpecker.Registry, error)) *MockClient_GlobalRegistry_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalRegistryCreate provides a mock function for the type MockClient
func (_mock *MockClient) GlobalRegistryCreate(registry *woodpecker.Registry) (*woodpecker.Registry, error) {
	ret := _mock.Called(registry)

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

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

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

// GlobalRegistryCreate is a helper method to define mock.On call
//   - registry *woodpecker.Registry
func (_e *MockClient_Expecter) GlobalRegistryCreate(registry interface{}) *MockClient_GlobalRegistryCreate_Call {
	return &MockClient_GlobalRegistryCreate_Call{Call: _e.mock.On("GlobalRegistryCreate", registry)}
}

func (_c *MockClient_GlobalRegistryCreate_Call) Run(run func(registry *woodpecker.Registry)) *MockClient_GlobalRegistryCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.Registry
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.Registry)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_GlobalRegistryCreate_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_GlobalRegistryCreate_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_GlobalRegistryCreate_Call) RunAndReturn(run func(registry *woodpecker.Registry) (*woodpecker.Registry, error)) *MockClient_GlobalRegistryCreate_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalRegistryDelete provides a mock function for the type MockClient
func (_mock *MockClient) GlobalRegistryDelete(registry string) error {
	ret := _mock.Called(registry)

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

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

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

// GlobalRegistryDelete is a helper method to define mock.On call
//   - registry string
func (_e *MockClient_Expecter) GlobalRegistryDelete(registry interface{}) *MockClient_GlobalRegistryDelete_Call {
	return &MockClient_GlobalRegistryDelete_Call{Call: _e.mock.On("GlobalRegistryDelete", registry)}
}

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

func (_c *MockClient_GlobalRegistryDelete_Call) RunAndReturn(run func(registry string) error) *MockClient_GlobalRegistryDelete_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalRegistryList provides a mock function for the type MockClient
func (_mock *MockClient) GlobalRegistryList(opt woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error) {
	ret := _mock.Called(opt)

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

	var r0 []*woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error)); ok {
		return returnFunc(opt)
	}
	if returnFunc, ok := ret.Get(0).(func(woodpecker.RegistryListOptions) []*woodpecker.Registry); ok {
		r0 = returnFunc(opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(woodpecker.RegistryListOptions) error); ok {
		r1 = returnFunc(opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GlobalRegistryList is a helper method to define mock.On call
//   - opt woodpecker.RegistryListOptions
func (_e *MockClient_Expecter) GlobalRegistryList(opt interface{}) *MockClient_GlobalRegistryList_Call {
	return &MockClient_GlobalRegistryList_Call{Call: _e.mock.On("GlobalRegistryList", opt)}
}

func (_c *MockClient_GlobalRegistryList_Call) Run(run func(opt woodpecker.RegistryListOptions)) *MockClient_GlobalRegistryList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 woodpecker.RegistryListOptions
		if args[0] != nil {
			arg0 = args[0].(woodpecker.RegistryListOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_GlobalRegistryList_Call) Return(registrys []*woodpecker.Registry, err error) *MockClient_GlobalRegistryList_Call {
	_c.Call.Return(registrys, err)
	return _c
}

func (_c *MockClient_GlobalRegistryList_Call) RunAndReturn(run func(opt woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error)) *MockClient_GlobalRegistryList_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalRegistryUpdate provides a mock function for the type MockClient
func (_mock *MockClient) GlobalRegistryUpdate(registry *woodpecker.Registry) (*woodpecker.Registry, error) {
	ret := _mock.Called(registry)

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

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

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

// GlobalRegistryUpdate is a helper method to define mock.On call
//   - registry *woodpecker.Registry
func (_e *MockClient_Expecter) GlobalRegistryUpdate(registry interface{}) *MockClient_GlobalRegistryUpdate_Call {
	return &MockClient_GlobalRegistryUpdate_Call{Call: _e.mock.On("GlobalRegistryUpdate", registry)}
}

func (_c *MockClient_GlobalRegistryUpdate_Call) Run(run func(registry *woodpecker.Registry)) *MockClient_GlobalRegistryUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.Registry
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.Registry)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_GlobalRegistryUpdate_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_GlobalRegistryUpdate_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_GlobalRegistryUpdate_Call) RunAndReturn(run func(registry *woodpecker.Registry) (*woodpecker.Registry, error)) *MockClient_GlobalRegistryUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecret provides a mock function for the type MockClient
func (_mock *MockClient) GlobalSecret(secret string) (*woodpecker.Secret, error) {
	ret := _mock.Called(secret)

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

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

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

// GlobalSecret is a helper method to define mock.On call
//   - secret string
func (_e *MockClient_Expecter) GlobalSecret(secret interface{}) *MockClient_GlobalSecret_Call {
	return &MockClient_GlobalSecret_Call{Call: _e.mock.On("GlobalSecret", secret)}
}

func (_c *MockClient_GlobalSecret_Call) Run(run func(secret string)) *MockClient_GlobalSecret_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 *MockClient_GlobalSecret_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_GlobalSecret_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_GlobalSecret_Call) RunAndReturn(run func(secret string) (*woodpecker.Secret, error)) *MockClient_GlobalSecret_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

func (_c *MockClient_GlobalSecretCreate_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_GlobalSecretCreate_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_GlobalSecretCreate_Call) RunAndReturn(run func(secret *woodpecker.Secret) (*woodpecker.Secret, error)) *MockClient_GlobalSecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

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

	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(secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

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

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

func (_c *MockClient_GlobalSecretDelete_Call) RunAndReturn(run func(secret string) error) *MockClient_GlobalSecretDelete_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecretList provides a mock function for the type MockClient
func (_mock *MockClient) GlobalSecretList(opt woodpecker.SecretListOptions) ([]*woodpecker.Secret, error) {
	ret := _mock.Called(opt)

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

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

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

// GlobalSecretList is a helper method to define mock.On call
//   - opt woodpecker.SecretListOptions
func (_e *MockClient_Expecter) GlobalSecretList(opt interface{}) *MockClient_GlobalSecretList_Call {
	return &MockClient_GlobalSecretList_Call{Call: _e.mock.On("GlobalSecretList", opt)}
}

func (_c *MockClient_GlobalSecretList_Call) Run(run func(opt woodpecker.SecretListOptions)) *MockClient_GlobalSecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 woodpecker.SecretListOptions
		if args[0] != nil {
			arg0 = args[0].(woodpecker.SecretListOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockClient_GlobalSecretList_Call) RunAndReturn(run func(opt woodpecker.SecretListOptions) ([]*woodpecker.Secret, error)) *MockClient_GlobalSecretList_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

func (_c *MockClient_GlobalSecretUpdate_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_GlobalSecretUpdate_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_GlobalSecretUpdate_Call) RunAndReturn(run func(secret *woodpecker.Secret) (*woodpecker.Secret, error)) *MockClient_GlobalSecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// LogLevel provides a mock function for the type MockClient
func (_mock *MockClient) LogLevel() (*woodpecker.LogLevel, error) {
	ret := _mock.Called()

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

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

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

// LogLevel is a helper method to define mock.On call
func (_e *MockClient_Expecter) LogLevel() *MockClient_LogLevel_Call {
	return &MockClient_LogLevel_Call{Call: _e.mock.On("LogLevel")}
}

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

func (_c *MockClient_LogLevel_Call) Return(logLevel *woodpecker.LogLevel, err error) *MockClient_LogLevel_Call {
	_c.Call.Return(logLevel, err)
	return _c
}

func (_c *MockClient_LogLevel_Call) RunAndReturn(run func() (*woodpecker.LogLevel, error)) *MockClient_LogLevel_Call {
	_c.Call.Return(run)
	return _c
}

// LogsPurge provides a mock function for the type MockClient
func (_mock *MockClient) LogsPurge(repoID int64, pipeline int64) error {
	ret := _mock.Called(repoID, pipeline)

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

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

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

// LogsPurge is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
func (_e *MockClient_Expecter) LogsPurge(repoID interface{}, pipeline interface{}) *MockClient_LogsPurge_Call {
	return &MockClient_LogsPurge_Call{Call: _e.mock.On("LogsPurge", repoID, pipeline)}
}

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

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

func (_c *MockClient_LogsPurge_Call) RunAndReturn(run func(repoID int64, pipeline int64) error) *MockClient_LogsPurge_Call {
	_c.Call.Return(run)
	return _c
}

// Org provides a mock function for the type MockClient
func (_mock *MockClient) Org(orgID int64) (*woodpecker.Org, error) {
	ret := _mock.Called(orgID)

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

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

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

// Org is a helper method to define mock.On call
//   - orgID int64
func (_e *MockClient_Expecter) Org(orgID interface{}) *MockClient_Org_Call {
	return &MockClient_Org_Call{Call: _e.mock.On("Org", orgID)}
}

func (_c *MockClient_Org_Call) Run(run func(orgID int64)) *MockClient_Org_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 *MockClient_Org_Call) Return(org *woodpecker.Org, err error) *MockClient_Org_Call {
	_c.Call.Return(org, err)
	return _c
}

func (_c *MockClient_Org_Call) RunAndReturn(run func(orgID int64) (*woodpecker.Org, error)) *MockClient_Org_Call {
	_c.Call.Return(run)
	return _c
}

// OrgList provides a mock function for the type MockClient
func (_mock *MockClient) OrgList(opt woodpecker.ListOptions) ([]*woodpecker.Org, error) {
	ret := _mock.Called(opt)

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

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

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

// OrgList is a helper method to define mock.On call
//   - opt woodpecker.ListOptions
func (_e *MockClient_Expecter) OrgList(opt interface{}) *MockClient_OrgList_Call {
	return &MockClient_OrgList_Call{Call: _e.mock.On("OrgList", opt)}
}

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

func (_c *MockClient_OrgList_Call) Return(orgs []*woodpecker.Org, err error) *MockClient_OrgList_Call {
	_c.Call.Return(orgs, err)
	return _c
}

func (_c *MockClient_OrgList_Call) RunAndReturn(run func(opt woodpecker.ListOptions) ([]*woodpecker.Org, error)) *MockClient_OrgList_Call {
	_c.Call.Return(run)
	return _c
}

// OrgLookup provides a mock function for the type MockClient
func (_mock *MockClient) OrgLookup(orgName string) (*woodpecker.Org, error) {
	ret := _mock.Called(orgName)

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

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

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

// OrgLookup is a helper method to define mock.On call
//   - orgName string
func (_e *MockClient_Expecter) OrgLookup(orgName interface{}) *MockClient_OrgLookup_Call {
	return &MockClient_OrgLookup_Call{Call: _e.mock.On("OrgLookup", orgName)}
}

func (_c *MockClient_OrgLookup_Call) Run(run func(orgName string)) *MockClient_OrgLookup_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 *MockClient_OrgLookup_Call) Return(org *woodpecker.Org, err error) *MockClient_OrgLookup_Call {
	_c.Call.Return(org, err)
	return _c
}

func (_c *MockClient_OrgLookup_Call) RunAndReturn(run func(orgName string) (*woodpecker.Org, error)) *MockClient_OrgLookup_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistry provides a mock function for the type MockClient
func (_mock *MockClient) OrgRegistry(orgID int64, registry string) (*woodpecker.Registry, error) {
	ret := _mock.Called(orgID, registry)

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

	var r0 *woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, string) (*woodpecker.Registry, error)); ok {
		return returnFunc(orgID, registry)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, string) *woodpecker.Registry); ok {
		r0 = returnFunc(orgID, registry)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = returnFunc(orgID, registry)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgRegistry is a helper method to define mock.On call
//   - orgID int64
//   - registry string
func (_e *MockClient_Expecter) OrgRegistry(orgID interface{}, registry interface{}) *MockClient_OrgRegistry_Call {
	return &MockClient_OrgRegistry_Call{Call: _e.mock.On("OrgRegistry", orgID, registry)}
}

func (_c *MockClient_OrgRegistry_Call) Run(run func(orgID int64, registry string)) *MockClient_OrgRegistry_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 *MockClient_OrgRegistry_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_OrgRegistry_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_OrgRegistry_Call) RunAndReturn(run func(orgID int64, registry string) (*woodpecker.Registry, error)) *MockClient_OrgRegistry_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistryCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrgRegistryCreate(orgID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) {
	ret := _mock.Called(orgID, registry)

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

	var r0 *woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok {
		return returnFunc(orgID, registry)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok {
		r0 = returnFunc(orgID, registry)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok {
		r1 = returnFunc(orgID, registry)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgRegistryCreate is a helper method to define mock.On call
//   - orgID int64
//   - registry *woodpecker.Registry
func (_e *MockClient_Expecter) OrgRegistryCreate(orgID interface{}, registry interface{}) *MockClient_OrgRegistryCreate_Call {
	return &MockClient_OrgRegistryCreate_Call{Call: _e.mock.On("OrgRegistryCreate", orgID, registry)}
}

func (_c *MockClient_OrgRegistryCreate_Call) Run(run func(orgID int64, registry *woodpecker.Registry)) *MockClient_OrgRegistryCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.Registry
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.Registry)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_OrgRegistryCreate_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_OrgRegistryCreate_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_OrgRegistryCreate_Call) RunAndReturn(run func(orgID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error)) *MockClient_OrgRegistryCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistryDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrgRegistryDelete(orgID int64, registry string) error {
	ret := _mock.Called(orgID, registry)

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

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

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

// OrgRegistryDelete is a helper method to define mock.On call
//   - orgID int64
//   - registry string
func (_e *MockClient_Expecter) OrgRegistryDelete(orgID interface{}, registry interface{}) *MockClient_OrgRegistryDelete_Call {
	return &MockClient_OrgRegistryDelete_Call{Call: _e.mock.On("OrgRegistryDelete", orgID, registry)}
}

func (_c *MockClient_OrgRegistryDelete_Call) Run(run func(orgID int64, registry string)) *MockClient_OrgRegistryDelete_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 *MockClient_OrgRegistryDelete_Call) Return(err error) *MockClient_OrgRegistryDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrgRegistryDelete_Call) RunAndReturn(run func(orgID int64, registry string) error) *MockClient_OrgRegistryDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistryList provides a mock function for the type MockClient
func (_mock *MockClient) OrgRegistryList(orgID int64, opt woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error) {
	ret := _mock.Called(orgID, opt)

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

	var r0 []*woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error)); ok {
		return returnFunc(orgID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.RegistryListOptions) []*woodpecker.Registry); ok {
		r0 = returnFunc(orgID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.RegistryListOptions) error); ok {
		r1 = returnFunc(orgID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgRegistryList is a helper method to define mock.On call
//   - orgID int64
//   - opt woodpecker.RegistryListOptions
func (_e *MockClient_Expecter) OrgRegistryList(orgID interface{}, opt interface{}) *MockClient_OrgRegistryList_Call {
	return &MockClient_OrgRegistryList_Call{Call: _e.mock.On("OrgRegistryList", orgID, opt)}
}

func (_c *MockClient_OrgRegistryList_Call) Run(run func(orgID int64, opt woodpecker.RegistryListOptions)) *MockClient_OrgRegistryList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.RegistryListOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.RegistryListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_OrgRegistryList_Call) Return(registrys []*woodpecker.Registry, err error) *MockClient_OrgRegistryList_Call {
	_c.Call.Return(registrys, err)
	return _c
}

func (_c *MockClient_OrgRegistryList_Call) RunAndReturn(run func(orgID int64, opt woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error)) *MockClient_OrgRegistryList_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistryUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrgRegistryUpdate(orgID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) {
	ret := _mock.Called(orgID, registry)

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

	var r0 *woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok {
		return returnFunc(orgID, registry)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok {
		r0 = returnFunc(orgID, registry)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok {
		r1 = returnFunc(orgID, registry)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgRegistryUpdate is a helper method to define mock.On call
//   - orgID int64
//   - registry *woodpecker.Registry
func (_e *MockClient_Expecter) OrgRegistryUpdate(orgID interface{}, registry interface{}) *MockClient_OrgRegistryUpdate_Call {
	return &MockClient_OrgRegistryUpdate_Call{Call: _e.mock.On("OrgRegistryUpdate", orgID, registry)}
}

func (_c *MockClient_OrgRegistryUpdate_Call) Run(run func(orgID int64, registry *woodpecker.Registry)) *MockClient_OrgRegistryUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.Registry
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.Registry)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_OrgRegistryUpdate_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_OrgRegistryUpdate_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_OrgRegistryUpdate_Call) RunAndReturn(run func(orgID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error)) *MockClient_OrgRegistryUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecret provides a mock function for the type MockClient
func (_mock *MockClient) OrgSecret(orgID int64, secret string) (*woodpecker.Secret, error) {
	ret := _mock.Called(orgID, secret)

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

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

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

// OrgSecret is a helper method to define mock.On call
//   - orgID int64
//   - secret string
func (_e *MockClient_Expecter) OrgSecret(orgID interface{}, secret interface{}) *MockClient_OrgSecret_Call {
	return &MockClient_OrgSecret_Call{Call: _e.mock.On("OrgSecret", orgID, secret)}
}

func (_c *MockClient_OrgSecret_Call) Run(run func(orgID int64, secret string)) *MockClient_OrgSecret_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 *MockClient_OrgSecret_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_OrgSecret_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_OrgSecret_Call) RunAndReturn(run func(orgID int64, secret string) (*woodpecker.Secret, error)) *MockClient_OrgSecret_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// OrgSecretCreate is a helper method to define mock.On call
//   - orgID int64
//   - secret *woodpecker.Secret
func (_e *MockClient_Expecter) OrgSecretCreate(orgID interface{}, secret interface{}) *MockClient_OrgSecretCreate_Call {
	return &MockClient_OrgSecretCreate_Call{Call: _e.mock.On("OrgSecretCreate", orgID, secret)}
}

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

func (_c *MockClient_OrgSecretCreate_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_OrgSecretCreate_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_OrgSecretCreate_Call) RunAndReturn(run func(orgID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error)) *MockClient_OrgSecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

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

	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(orgID, secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrgSecretDelete is a helper method to define mock.On call
//   - orgID int64
//   - secret string
func (_e *MockClient_Expecter) OrgSecretDelete(orgID interface{}, secret interface{}) *MockClient_OrgSecretDelete_Call {
	return &MockClient_OrgSecretDelete_Call{Call: _e.mock.On("OrgSecretDelete", orgID, secret)}
}

func (_c *MockClient_OrgSecretDelete_Call) Run(run func(orgID int64, secret string)) *MockClient_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 *MockClient_OrgSecretDelete_Call) Return(err error) *MockClient_OrgSecretDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrgSecretDelete_Call) RunAndReturn(run func(orgID int64, secret string) error) *MockClient_OrgSecretDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretList provides a mock function for the type MockClient
func (_mock *MockClient) OrgSecretList(orgID int64, opt woodpecker.SecretListOptions) ([]*woodpecker.Secret, error) {
	ret := _mock.Called(orgID, opt)

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

	var r0 []*woodpecker.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.SecretListOptions) ([]*woodpecker.Secret, error)); ok {
		return returnFunc(orgID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.SecretListOptions) []*woodpecker.Secret); ok {
		r0 = returnFunc(orgID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.SecretListOptions) error); ok {
		r1 = returnFunc(orgID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrgSecretList is a helper method to define mock.On call
//   - orgID int64
//   - opt woodpecker.SecretListOptions
func (_e *MockClient_Expecter) OrgSecretList(orgID interface{}, opt interface{}) *MockClient_OrgSecretList_Call {
	return &MockClient_OrgSecretList_Call{Call: _e.mock.On("OrgSecretList", orgID, opt)}
}

func (_c *MockClient_OrgSecretList_Call) Run(run func(orgID int64, opt woodpecker.SecretListOptions)) *MockClient_OrgSecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.SecretListOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.SecretListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockClient_OrgSecretList_Call) RunAndReturn(run func(orgID int64, opt woodpecker.SecretListOptions) ([]*woodpecker.Secret, error)) *MockClient_OrgSecretList_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// OrgSecretUpdate is a helper method to define mock.On call
//   - orgID int64
//   - secret *woodpecker.Secret
func (_e *MockClient_Expecter) OrgSecretUpdate(orgID interface{}, secret interface{}) *MockClient_OrgSecretUpdate_Call {
	return &MockClient_OrgSecretUpdate_Call{Call: _e.mock.On("OrgSecretUpdate", orgID, secret)}
}

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

func (_c *MockClient_OrgSecretUpdate_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_OrgSecretUpdate_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_OrgSecretUpdate_Call) RunAndReturn(run func(orgID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error)) *MockClient_OrgSecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// Pipeline provides a mock function for the type MockClient
func (_mock *MockClient) Pipeline(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, pipeline)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, pipeline)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, pipeline)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64) error); ok {
		r1 = returnFunc(repoID, pipeline)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Pipeline is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
func (_e *MockClient_Expecter) Pipeline(repoID interface{}, pipeline interface{}) *MockClient_Pipeline_Call {
	return &MockClient_Pipeline_Call{Call: _e.mock.On("Pipeline", repoID, pipeline)}
}

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

func (_c *MockClient_Pipeline_Call) Return(pipeline1 *woodpecker.Pipeline, err error) *MockClient_Pipeline_Call {
	_c.Call.Return(pipeline1, err)
	return _c
}

func (_c *MockClient_Pipeline_Call) RunAndReturn(run func(repoID int64, pipeline int64) (*woodpecker.Pipeline, error)) *MockClient_Pipeline_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineApprove provides a mock function for the type MockClient
func (_mock *MockClient) PipelineApprove(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, pipeline)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, pipeline)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, pipeline)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64) error); ok {
		r1 = returnFunc(repoID, pipeline)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PipelineApprove is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
func (_e *MockClient_Expecter) PipelineApprove(repoID interface{}, pipeline interface{}) *MockClient_PipelineApprove_Call {
	return &MockClient_PipelineApprove_Call{Call: _e.mock.On("PipelineApprove", repoID, pipeline)}
}

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

func (_c *MockClient_PipelineApprove_Call) Return(pipeline1 *woodpecker.Pipeline, err error) *MockClient_PipelineApprove_Call {
	_c.Call.Return(pipeline1, err)
	return _c
}

func (_c *MockClient_PipelineApprove_Call) RunAndReturn(run func(repoID int64, pipeline int64) (*woodpecker.Pipeline, error)) *MockClient_PipelineApprove_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineCreate provides a mock function for the type MockClient
func (_mock *MockClient) PipelineCreate(repoID int64, opts *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, opts)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.PipelineOptions) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.PipelineOptions) error); ok {
		r1 = returnFunc(repoID, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PipelineCreate is a helper method to define mock.On call
//   - repoID int64
//   - opts *woodpecker.PipelineOptions
func (_e *MockClient_Expecter) PipelineCreate(repoID interface{}, opts interface{}) *MockClient_PipelineCreate_Call {
	return &MockClient_PipelineCreate_Call{Call: _e.mock.On("PipelineCreate", repoID, opts)}
}

func (_c *MockClient_PipelineCreate_Call) Run(run func(repoID int64, opts *woodpecker.PipelineOptions)) *MockClient_PipelineCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.PipelineOptions
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.PipelineOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_PipelineCreate_Call) Return(pipeline *woodpecker.Pipeline, err error) *MockClient_PipelineCreate_Call {
	_c.Call.Return(pipeline, err)
	return _c
}

func (_c *MockClient_PipelineCreate_Call) RunAndReturn(run func(repoID int64, opts *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error)) *MockClient_PipelineCreate_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineDecline provides a mock function for the type MockClient
func (_mock *MockClient) PipelineDecline(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, pipeline)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, pipeline)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, pipeline)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64) error); ok {
		r1 = returnFunc(repoID, pipeline)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PipelineDecline is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
func (_e *MockClient_Expecter) PipelineDecline(repoID interface{}, pipeline interface{}) *MockClient_PipelineDecline_Call {
	return &MockClient_PipelineDecline_Call{Call: _e.mock.On("PipelineDecline", repoID, pipeline)}
}

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

func (_c *MockClient_PipelineDecline_Call) Return(pipeline1 *woodpecker.Pipeline, err error) *MockClient_PipelineDecline_Call {
	_c.Call.Return(pipeline1, err)
	return _c
}

func (_c *MockClient_PipelineDecline_Call) RunAndReturn(run func(repoID int64, pipeline int64) (*woodpecker.Pipeline, error)) *MockClient_PipelineDecline_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineDelete provides a mock function for the type MockClient
func (_mock *MockClient) PipelineDelete(repoID int64, pipeline int64) error {
	ret := _mock.Called(repoID, pipeline)

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

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

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

// PipelineDelete is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
func (_e *MockClient_Expecter) PipelineDelete(repoID interface{}, pipeline interface{}) *MockClient_PipelineDelete_Call {
	return &MockClient_PipelineDelete_Call{Call: _e.mock.On("PipelineDelete", repoID, pipeline)}
}

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

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

func (_c *MockClient_PipelineDelete_Call) RunAndReturn(run func(repoID int64, pipeline int64) error) *MockClient_PipelineDelete_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineLast provides a mock function for the type MockClient
func (_mock *MockClient) PipelineLast(repoID int64, opt woodpecker.PipelineLastOptions) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, opt)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.PipelineLastOptions) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.PipelineLastOptions) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.PipelineLastOptions) error); ok {
		r1 = returnFunc(repoID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PipelineLast is a helper method to define mock.On call
//   - repoID int64
//   - opt woodpecker.PipelineLastOptions
func (_e *MockClient_Expecter) PipelineLast(repoID interface{}, opt interface{}) *MockClient_PipelineLast_Call {
	return &MockClient_PipelineLast_Call{Call: _e.mock.On("PipelineLast", repoID, opt)}
}

func (_c *MockClient_PipelineLast_Call) Run(run func(repoID int64, opt woodpecker.PipelineLastOptions)) *MockClient_PipelineLast_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.PipelineLastOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.PipelineLastOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_PipelineLast_Call) Return(pipeline *woodpecker.Pipeline, err error) *MockClient_PipelineLast_Call {
	_c.Call.Return(pipeline, err)
	return _c
}

func (_c *MockClient_PipelineLast_Call) RunAndReturn(run func(repoID int64, opt woodpecker.PipelineLastOptions) (*woodpecker.Pipeline, error)) *MockClient_PipelineLast_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineList provides a mock function for the type MockClient
func (_mock *MockClient) PipelineList(repoID int64, opt woodpecker.PipelineListOptions) ([]*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, opt)

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

	var r0 []*woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.PipelineListOptions) ([]*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.PipelineListOptions) []*woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.PipelineListOptions) error); ok {
		r1 = returnFunc(repoID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PipelineList is a helper method to define mock.On call
//   - repoID int64
//   - opt woodpecker.PipelineListOptions
func (_e *MockClient_Expecter) PipelineList(repoID interface{}, opt interface{}) *MockClient_PipelineList_Call {
	return &MockClient_PipelineList_Call{Call: _e.mock.On("PipelineList", repoID, opt)}
}

func (_c *MockClient_PipelineList_Call) Run(run func(repoID int64, opt woodpecker.PipelineListOptions)) *MockClient_PipelineList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.PipelineListOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.PipelineListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_PipelineList_Call) Return(pipelines []*woodpecker.Pipeline, err error) *MockClient_PipelineList_Call {
	_c.Call.Return(pipelines, err)
	return _c
}

func (_c *MockClient_PipelineList_Call) RunAndReturn(run func(repoID int64, opt woodpecker.PipelineListOptions) ([]*woodpecker.Pipeline, error)) *MockClient_PipelineList_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineMetadata provides a mock function for the type MockClient
func (_mock *MockClient) PipelineMetadata(repoID int64, pipelineNumber int) ([]byte, error) {
	ret := _mock.Called(repoID, pipelineNumber)

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

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

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

// PipelineMetadata is a helper method to define mock.On call
//   - repoID int64
//   - pipelineNumber int
func (_e *MockClient_Expecter) PipelineMetadata(repoID interface{}, pipelineNumber interface{}) *MockClient_PipelineMetadata_Call {
	return &MockClient_PipelineMetadata_Call{Call: _e.mock.On("PipelineMetadata", repoID, pipelineNumber)}
}

func (_c *MockClient_PipelineMetadata_Call) Run(run func(repoID int64, pipelineNumber int)) *MockClient_PipelineMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockClient_PipelineMetadata_Call) RunAndReturn(run func(repoID int64, pipelineNumber int) ([]byte, error)) *MockClient_PipelineMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineQueue provides a mock function for the type MockClient
func (_mock *MockClient) PipelineQueue() ([]*woodpecker.Feed, error) {
	ret := _mock.Called()

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

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

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

// PipelineQueue is a helper method to define mock.On call
func (_e *MockClient_Expecter) PipelineQueue() *MockClient_PipelineQueue_Call {
	return &MockClient_PipelineQueue_Call{Call: _e.mock.On("PipelineQueue")}
}

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

func (_c *MockClient_PipelineQueue_Call) Return(feeds []*woodpecker.Feed, err error) *MockClient_PipelineQueue_Call {
	_c.Call.Return(feeds, err)
	return _c
}

func (_c *MockClient_PipelineQueue_Call) RunAndReturn(run func() ([]*woodpecker.Feed, error)) *MockClient_PipelineQueue_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineStart provides a mock function for the type MockClient
func (_mock *MockClient) PipelineStart(repoID int64, num int64, opt woodpecker.PipelineStartOptions) (*woodpecker.Pipeline, error) {
	ret := _mock.Called(repoID, num, opt)

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

	var r0 *woodpecker.Pipeline
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64, woodpecker.PipelineStartOptions) (*woodpecker.Pipeline, error)); ok {
		return returnFunc(repoID, num, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64, woodpecker.PipelineStartOptions) *woodpecker.Pipeline); ok {
		r0 = returnFunc(repoID, num, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Pipeline)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64, woodpecker.PipelineStartOptions) error); ok {
		r1 = returnFunc(repoID, num, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PipelineStart is a helper method to define mock.On call
//   - repoID int64
//   - num int64
//   - opt woodpecker.PipelineStartOptions
func (_e *MockClient_Expecter) PipelineStart(repoID interface{}, num interface{}, opt interface{}) *MockClient_PipelineStart_Call {
	return &MockClient_PipelineStart_Call{Call: _e.mock.On("PipelineStart", repoID, num, opt)}
}

func (_c *MockClient_PipelineStart_Call) Run(run func(repoID int64, num int64, opt woodpecker.PipelineStartOptions)) *MockClient_PipelineStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 woodpecker.PipelineStartOptions
		if args[2] != nil {
			arg2 = args[2].(woodpecker.PipelineStartOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockClient_PipelineStart_Call) Return(pipeline *woodpecker.Pipeline, err error) *MockClient_PipelineStart_Call {
	_c.Call.Return(pipeline, err)
	return _c
}

func (_c *MockClient_PipelineStart_Call) RunAndReturn(run func(repoID int64, num int64, opt woodpecker.PipelineStartOptions) (*woodpecker.Pipeline, error)) *MockClient_PipelineStart_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineStop provides a mock function for the type MockClient
func (_mock *MockClient) PipelineStop(repoID int64, pipeline int64) error {
	ret := _mock.Called(repoID, pipeline)

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

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

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

// PipelineStop is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
func (_e *MockClient_Expecter) PipelineStop(repoID interface{}, pipeline interface{}) *MockClient_PipelineStop_Call {
	return &MockClient_PipelineStop_Call{Call: _e.mock.On("PipelineStop", repoID, pipeline)}
}

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

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

func (_c *MockClient_PipelineStop_Call) RunAndReturn(run func(repoID int64, pipeline int64) error) *MockClient_PipelineStop_Call {
	_c.Call.Return(run)
	return _c
}

// QueueInfo provides a mock function for the type MockClient
func (_mock *MockClient) QueueInfo() (*woodpecker.Info, error) {
	ret := _mock.Called()

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

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

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

// QueueInfo is a helper method to define mock.On call
func (_e *MockClient_Expecter) QueueInfo() *MockClient_QueueInfo_Call {
	return &MockClient_QueueInfo_Call{Call: _e.mock.On("QueueInfo")}
}

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

func (_c *MockClient_QueueInfo_Call) Return(info *woodpecker.Info, err error) *MockClient_QueueInfo_Call {
	_c.Call.Return(info, err)
	return _c
}

func (_c *MockClient_QueueInfo_Call) RunAndReturn(run func() (*woodpecker.Info, error)) *MockClient_QueueInfo_Call {
	_c.Call.Return(run)
	return _c
}

// Registry provides a mock function for the type MockClient
func (_mock *MockClient) Registry(repoID int64, hostname string) (*woodpecker.Registry, error) {
	ret := _mock.Called(repoID, hostname)

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

	var r0 *woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, string) (*woodpecker.Registry, error)); ok {
		return returnFunc(repoID, hostname)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, string) *woodpecker.Registry); ok {
		r0 = returnFunc(repoID, hostname)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = returnFunc(repoID, hostname)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Registry is a helper method to define mock.On call
//   - repoID int64
//   - hostname string
func (_e *MockClient_Expecter) Registry(repoID interface{}, hostname interface{}) *MockClient_Registry_Call {
	return &MockClient_Registry_Call{Call: _e.mock.On("Registry", repoID, hostname)}
}

func (_c *MockClient_Registry_Call) Run(run func(repoID int64, hostname string)) *MockClient_Registry_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 *MockClient_Registry_Call) Return(registry *woodpecker.Registry, err error) *MockClient_Registry_Call {
	_c.Call.Return(registry, err)
	return _c
}

func (_c *MockClient_Registry_Call) RunAndReturn(run func(repoID int64, hostname string) (*woodpecker.Registry, error)) *MockClient_Registry_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryCreate provides a mock function for the type MockClient
func (_mock *MockClient) RegistryCreate(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) {
	ret := _mock.Called(repoID, registry)

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

	var r0 *woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok {
		return returnFunc(repoID, registry)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok {
		r0 = returnFunc(repoID, registry)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok {
		r1 = returnFunc(repoID, registry)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RegistryCreate is a helper method to define mock.On call
//   - repoID int64
//   - registry *woodpecker.Registry
func (_e *MockClient_Expecter) RegistryCreate(repoID interface{}, registry interface{}) *MockClient_RegistryCreate_Call {
	return &MockClient_RegistryCreate_Call{Call: _e.mock.On("RegistryCreate", repoID, registry)}
}

func (_c *MockClient_RegistryCreate_Call) Run(run func(repoID int64, registry *woodpecker.Registry)) *MockClient_RegistryCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.Registry
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.Registry)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_RegistryCreate_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_RegistryCreate_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_RegistryCreate_Call) RunAndReturn(run func(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error)) *MockClient_RegistryCreate_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryDelete provides a mock function for the type MockClient
func (_mock *MockClient) RegistryDelete(repoID int64, hostname string) error {
	ret := _mock.Called(repoID, hostname)

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

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

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

// RegistryDelete is a helper method to define mock.On call
//   - repoID int64
//   - hostname string
func (_e *MockClient_Expecter) RegistryDelete(repoID interface{}, hostname interface{}) *MockClient_RegistryDelete_Call {
	return &MockClient_RegistryDelete_Call{Call: _e.mock.On("RegistryDelete", repoID, hostname)}
}

func (_c *MockClient_RegistryDelete_Call) Run(run func(repoID int64, hostname string)) *MockClient_RegistryDelete_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 *MockClient_RegistryDelete_Call) Return(err error) *MockClient_RegistryDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_RegistryDelete_Call) RunAndReturn(run func(repoID int64, hostname string) error) *MockClient_RegistryDelete_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryList provides a mock function for the type MockClient
func (_mock *MockClient) RegistryList(repoID int64, opt woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error) {
	ret := _mock.Called(repoID, opt)

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

	var r0 []*woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error)); ok {
		return returnFunc(repoID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.RegistryListOptions) []*woodpecker.Registry); ok {
		r0 = returnFunc(repoID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.RegistryListOptions) error); ok {
		r1 = returnFunc(repoID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RegistryList is a helper method to define mock.On call
//   - repoID int64
//   - opt woodpecker.RegistryListOptions
func (_e *MockClient_Expecter) RegistryList(repoID interface{}, opt interface{}) *MockClient_RegistryList_Call {
	return &MockClient_RegistryList_Call{Call: _e.mock.On("RegistryList", repoID, opt)}
}

func (_c *MockClient_RegistryList_Call) Run(run func(repoID int64, opt woodpecker.RegistryListOptions)) *MockClient_RegistryList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.RegistryListOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.RegistryListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_RegistryList_Call) Return(registrys []*woodpecker.Registry, err error) *MockClient_RegistryList_Call {
	_c.Call.Return(registrys, err)
	return _c
}

func (_c *MockClient_RegistryList_Call) RunAndReturn(run func(repoID int64, opt woodpecker.RegistryListOptions) ([]*woodpecker.Registry, error)) *MockClient_RegistryList_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryUpdate provides a mock function for the type MockClient
func (_mock *MockClient) RegistryUpdate(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) {
	ret := _mock.Called(repoID, registry)

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

	var r0 *woodpecker.Registry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok {
		return returnFunc(repoID, registry)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok {
		r0 = returnFunc(repoID, registry)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Registry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok {
		r1 = returnFunc(repoID, registry)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RegistryUpdate is a helper method to define mock.On call
//   - repoID int64
//   - registry *woodpecker.Registry
func (_e *MockClient_Expecter) RegistryUpdate(repoID interface{}, registry interface{}) *MockClient_RegistryUpdate_Call {
	return &MockClient_RegistryUpdate_Call{Call: _e.mock.On("RegistryUpdate", repoID, registry)}
}

func (_c *MockClient_RegistryUpdate_Call) Run(run func(repoID int64, registry *woodpecker.Registry)) *MockClient_RegistryUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.Registry
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.Registry)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_RegistryUpdate_Call) Return(registry1 *woodpecker.Registry, err error) *MockClient_RegistryUpdate_Call {
	_c.Call.Return(registry1, err)
	return _c
}

func (_c *MockClient_RegistryUpdate_Call) RunAndReturn(run func(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error)) *MockClient_RegistryUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// Repo provides a mock function for the type MockClient
func (_mock *MockClient) Repo(repoID int64) (*woodpecker.Repo, error) {
	ret := _mock.Called(repoID)

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

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

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

// Repo is a helper method to define mock.On call
//   - repoID int64
func (_e *MockClient_Expecter) Repo(repoID interface{}) *MockClient_Repo_Call {
	return &MockClient_Repo_Call{Call: _e.mock.On("Repo", repoID)}
}

func (_c *MockClient_Repo_Call) Run(run func(repoID int64)) *MockClient_Repo_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 *MockClient_Repo_Call) Return(repo *woodpecker.Repo, err error) *MockClient_Repo_Call {
	_c.Call.Return(repo, err)
	return _c
}

func (_c *MockClient_Repo_Call) RunAndReturn(run func(repoID int64) (*woodpecker.Repo, error)) *MockClient_Repo_Call {
	_c.Call.Return(run)
	return _c
}

// RepoChown provides a mock function for the type MockClient
func (_mock *MockClient) RepoChown(repoID int64) (*woodpecker.Repo, error) {
	ret := _mock.Called(repoID)

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

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

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

// RepoChown is a helper method to define mock.On call
//   - repoID int64
func (_e *MockClient_Expecter) RepoChown(repoID interface{}) *MockClient_RepoChown_Call {
	return &MockClient_RepoChown_Call{Call: _e.mock.On("RepoChown", repoID)}
}

func (_c *MockClient_RepoChown_Call) Run(run func(repoID int64)) *MockClient_RepoChown_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 *MockClient_RepoChown_Call) Return(repo *woodpecker.Repo, err error) *MockClient_RepoChown_Call {
	_c.Call.Return(repo, err)
	return _c
}

func (_c *MockClient_RepoChown_Call) RunAndReturn(run func(repoID int64) (*woodpecker.Repo, error)) *MockClient_RepoChown_Call {
	_c.Call.Return(run)
	return _c
}

// RepoDel provides a mock function for the type MockClient
func (_mock *MockClient) RepoDel(repoID int64) error {
	ret := _mock.Called(repoID)

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

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

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

// RepoDel is a helper method to define mock.On call
//   - repoID int64
func (_e *MockClient_Expecter) RepoDel(repoID interface{}) *MockClient_RepoDel_Call {
	return &MockClient_RepoDel_Call{Call: _e.mock.On("RepoDel", repoID)}
}

func (_c *MockClient_RepoDel_Call) Run(run func(repoID int64)) *MockClient_RepoDel_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 *MockClient_RepoDel_Call) Return(err error) *MockClient_RepoDel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_RepoDel_Call) RunAndReturn(run func(repoID int64) error) *MockClient_RepoDel_Call {
	_c.Call.Return(run)
	return _c
}

// RepoList provides a mock function for the type MockClient
func (_mock *MockClient) RepoList(opt woodpecker.RepoListOptions) ([]*woodpecker.Repo, error) {
	ret := _mock.Called(opt)

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

	var r0 []*woodpecker.Repo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(woodpecker.RepoListOptions) ([]*woodpecker.Repo, error)); ok {
		return returnFunc(opt)
	}
	if returnFunc, ok := ret.Get(0).(func(woodpecker.RepoListOptions) []*woodpecker.Repo); ok {
		r0 = returnFunc(opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Repo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(woodpecker.RepoListOptions) error); ok {
		r1 = returnFunc(opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RepoList is a helper method to define mock.On call
//   - opt woodpecker.RepoListOptions
func (_e *MockClient_Expecter) RepoList(opt interface{}) *MockClient_RepoList_Call {
	return &MockClient_RepoList_Call{Call: _e.mock.On("RepoList", opt)}
}

func (_c *MockClient_RepoList_Call) Run(run func(opt woodpecker.RepoListOptions)) *MockClient_RepoList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 woodpecker.RepoListOptions
		if args[0] != nil {
			arg0 = args[0].(woodpecker.RepoListOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_RepoList_Call) Return(repos []*woodpecker.Repo, err error) *MockClient_RepoList_Call {
	_c.Call.Return(repos, err)
	return _c
}

func (_c *MockClient_RepoList_Call) RunAndReturn(run func(opt woodpecker.RepoListOptions) ([]*woodpecker.Repo, error)) *MockClient_RepoList_Call {
	_c.Call.Return(run)
	return _c
}

// RepoLookup provides a mock function for the type MockClient
func (_mock *MockClient) RepoLookup(repoFullName string) (*woodpecker.Repo, error) {
	ret := _mock.Called(repoFullName)

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

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

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

// RepoLookup is a helper method to define mock.On call
//   - repoFullName string
func (_e *MockClient_Expecter) RepoLookup(repoFullName interface{}) *MockClient_RepoLookup_Call {
	return &MockClient_RepoLookup_Call{Call: _e.mock.On("RepoLookup", repoFullName)}
}

func (_c *MockClient_RepoLookup_Call) Run(run func(repoFullName string)) *MockClient_RepoLookup_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 *MockClient_RepoLookup_Call) Return(repo *woodpecker.Repo, err error) *MockClient_RepoLookup_Call {
	_c.Call.Return(repo, err)
	return _c
}

func (_c *MockClient_RepoLookup_Call) RunAndReturn(run func(repoFullName string) (*woodpecker.Repo, error)) *MockClient_RepoLookup_Call {
	_c.Call.Return(run)
	return _c
}

// RepoMove provides a mock function for the type MockClient
func (_mock *MockClient) RepoMove(repoID int64, opt woodpecker.RepoMoveOptions) error {
	ret := _mock.Called(repoID, opt)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.RepoMoveOptions) error); ok {
		r0 = returnFunc(repoID, opt)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// RepoMove is a helper method to define mock.On call
//   - repoID int64
//   - opt woodpecker.RepoMoveOptions
func (_e *MockClient_Expecter) RepoMove(repoID interface{}, opt interface{}) *MockClient_RepoMove_Call {
	return &MockClient_RepoMove_Call{Call: _e.mock.On("RepoMove", repoID, opt)}
}

func (_c *MockClient_RepoMove_Call) Run(run func(repoID int64, opt woodpecker.RepoMoveOptions)) *MockClient_RepoMove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.RepoMoveOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.RepoMoveOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockClient_RepoMove_Call) RunAndReturn(run func(repoID int64, opt woodpecker.RepoMoveOptions) error) *MockClient_RepoMove_Call {
	_c.Call.Return(run)
	return _c
}

// RepoPatch provides a mock function for the type MockClient
func (_mock *MockClient) RepoPatch(repoID int64, repo *woodpecker.RepoPatch) (*woodpecker.Repo, error) {
	ret := _mock.Called(repoID, repo)

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

	var r0 *woodpecker.Repo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.RepoPatch) (*woodpecker.Repo, error)); ok {
		return returnFunc(repoID, repo)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, *woodpecker.RepoPatch) *woodpecker.Repo); ok {
		r0 = returnFunc(repoID, repo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.Repo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, *woodpecker.RepoPatch) error); ok {
		r1 = returnFunc(repoID, repo)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RepoPatch is a helper method to define mock.On call
//   - repoID int64
//   - repo *woodpecker.RepoPatch
func (_e *MockClient_Expecter) RepoPatch(repoID interface{}, repo interface{}) *MockClient_RepoPatch_Call {
	return &MockClient_RepoPatch_Call{Call: _e.mock.On("RepoPatch", repoID, repo)}
}

func (_c *MockClient_RepoPatch_Call) Run(run func(repoID int64, repo *woodpecker.RepoPatch)) *MockClient_RepoPatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 *woodpecker.RepoPatch
		if args[1] != nil {
			arg1 = args[1].(*woodpecker.RepoPatch)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_RepoPatch_Call) Return(repo1 *woodpecker.Repo, err error) *MockClient_RepoPatch_Call {
	_c.Call.Return(repo1, err)
	return _c
}

func (_c *MockClient_RepoPatch_Call) RunAndReturn(run func(repoID int64, repo *woodpecker.RepoPatch) (*woodpecker.Repo, error)) *MockClient_RepoPatch_Call {
	_c.Call.Return(run)
	return _c
}

// RepoPost provides a mock function for the type MockClient
func (_mock *MockClient) RepoPost(opt woodpecker.RepoPostOptions) (*woodpecker.Repo, error) {
	ret := _mock.Called(opt)

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

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

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

// RepoPost is a helper method to define mock.On call
//   - opt woodpecker.RepoPostOptions
func (_e *MockClient_Expecter) RepoPost(opt interface{}) *MockClient_RepoPost_Call {
	return &MockClient_RepoPost_Call{Call: _e.mock.On("RepoPost", opt)}
}

func (_c *MockClient_RepoPost_Call) Run(run func(opt woodpecker.RepoPostOptions)) *MockClient_RepoPost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 woodpecker.RepoPostOptions
		if args[0] != nil {
			arg0 = args[0].(woodpecker.RepoPostOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_RepoPost_Call) Return(repo *woodpecker.Repo, err error) *MockClient_RepoPost_Call {
	_c.Call.Return(repo, err)
	return _c
}

func (_c *MockClient_RepoPost_Call) RunAndReturn(run func(opt woodpecker.RepoPostOptions) (*woodpecker.Repo, error)) *MockClient_RepoPost_Call {
	_c.Call.Return(run)
	return _c
}

// RepoRepair provides a mock function for the type MockClient
func (_mock *MockClient) RepoRepair(repoID int64) error {
	ret := _mock.Called(repoID)

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

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

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

// RepoRepair is a helper method to define mock.On call
//   - repoID int64
func (_e *MockClient_Expecter) RepoRepair(repoID interface{}) *MockClient_RepoRepair_Call {
	return &MockClient_RepoRepair_Call{Call: _e.mock.On("RepoRepair", repoID)}
}

func (_c *MockClient_RepoRepair_Call) Run(run func(repoID int64)) *MockClient_RepoRepair_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 *MockClient_RepoRepair_Call) Return(err error) *MockClient_RepoRepair_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_RepoRepair_Call) RunAndReturn(run func(repoID int64) error) *MockClient_RepoRepair_Call {
	_c.Call.Return(run)
	return _c
}

// Secret provides a mock function for the type MockClient
func (_mock *MockClient) Secret(repoID int64, secret string) (*woodpecker.Secret, error) {
	ret := _mock.Called(repoID, secret)

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

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

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

// Secret is a helper method to define mock.On call
//   - repoID int64
//   - secret string
func (_e *MockClient_Expecter) Secret(repoID interface{}, secret interface{}) *MockClient_Secret_Call {
	return &MockClient_Secret_Call{Call: _e.mock.On("Secret", repoID, secret)}
}

func (_c *MockClient_Secret_Call) Run(run func(repoID int64, secret string)) *MockClient_Secret_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 *MockClient_Secret_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_Secret_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_Secret_Call) RunAndReturn(run func(repoID int64, secret string) (*woodpecker.Secret, error)) *MockClient_Secret_Call {
	_c.Call.Return(run)
	return _c
}

// SecretCreate provides a mock function for the type MockClient
func (_mock *MockClient) SecretCreate(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) {
	ret := _mock.Called(repoID, secret)

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

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

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

// SecretCreate is a helper method to define mock.On call
//   - repoID int64
//   - secret *woodpecker.Secret
func (_e *MockClient_Expecter) SecretCreate(repoID interface{}, secret interface{}) *MockClient_SecretCreate_Call {
	return &MockClient_SecretCreate_Call{Call: _e.mock.On("SecretCreate", repoID, secret)}
}

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

func (_c *MockClient_SecretCreate_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_SecretCreate_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_SecretCreate_Call) RunAndReturn(run func(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error)) *MockClient_SecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

// SecretDelete provides a mock function for the type MockClient
func (_mock *MockClient) SecretDelete(repoID int64, secret string) error {
	ret := _mock.Called(repoID, secret)

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

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

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

// SecretDelete is a helper method to define mock.On call
//   - repoID int64
//   - secret string
func (_e *MockClient_Expecter) SecretDelete(repoID interface{}, secret interface{}) *MockClient_SecretDelete_Call {
	return &MockClient_SecretDelete_Call{Call: _e.mock.On("SecretDelete", repoID, secret)}
}

func (_c *MockClient_SecretDelete_Call) Run(run func(repoID int64, secret string)) *MockClient_SecretDelete_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 *MockClient_SecretDelete_Call) Return(err error) *MockClient_SecretDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_SecretDelete_Call) RunAndReturn(run func(repoID int64, secret string) error) *MockClient_SecretDelete_Call {
	_c.Call.Return(run)
	return _c
}

// SecretList provides a mock function for the type MockClient
func (_mock *MockClient) SecretList(repoID int64, opt woodpecker.SecretListOptions) ([]*woodpecker.Secret, error) {
	ret := _mock.Called(repoID, opt)

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

	var r0 []*woodpecker.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.SecretListOptions) ([]*woodpecker.Secret, error)); ok {
		return returnFunc(repoID, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, woodpecker.SecretListOptions) []*woodpecker.Secret); ok {
		r0 = returnFunc(repoID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, woodpecker.SecretListOptions) error); ok {
		r1 = returnFunc(repoID, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SecretList is a helper method to define mock.On call
//   - repoID int64
//   - opt woodpecker.SecretListOptions
func (_e *MockClient_Expecter) SecretList(repoID interface{}, opt interface{}) *MockClient_SecretList_Call {
	return &MockClient_SecretList_Call{Call: _e.mock.On("SecretList", repoID, opt)}
}

func (_c *MockClient_SecretList_Call) Run(run func(repoID int64, opt woodpecker.SecretListOptions)) *MockClient_SecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 woodpecker.SecretListOptions
		if args[1] != nil {
			arg1 = args[1].(woodpecker.SecretListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockClient_SecretList_Call) RunAndReturn(run func(repoID int64, opt woodpecker.SecretListOptions) ([]*woodpecker.Secret, error)) *MockClient_SecretList_Call {
	_c.Call.Return(run)
	return _c
}

// SecretUpdate provides a mock function for the type MockClient
func (_mock *MockClient) SecretUpdate(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) {
	ret := _mock.Called(repoID, secret)

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

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

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

// SecretUpdate is a helper method to define mock.On call
//   - repoID int64
//   - secret *woodpecker.Secret
func (_e *MockClient_Expecter) SecretUpdate(repoID interface{}, secret interface{}) *MockClient_SecretUpdate_Call {
	return &MockClient_SecretUpdate_Call{Call: _e.mock.On("SecretUpdate", repoID, secret)}
}

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

func (_c *MockClient_SecretUpdate_Call) Return(secret1 *woodpecker.Secret, err error) *MockClient_SecretUpdate_Call {
	_c.Call.Return(secret1, err)
	return _c
}

func (_c *MockClient_SecretUpdate_Call) RunAndReturn(run func(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error)) *MockClient_SecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// Self provides a mock function for the type MockClient
func (_mock *MockClient) Self() (*woodpecker.User, error) {
	ret := _mock.Called()

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

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

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

// Self is a helper method to define mock.On call
func (_e *MockClient_Expecter) Self() *MockClient_Self_Call {
	return &MockClient_Self_Call{Call: _e.mock.On("Self")}
}

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

func (_c *MockClient_Self_Call) Return(user *woodpecker.User, err error) *MockClient_Self_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *MockClient_Self_Call) RunAndReturn(run func() (*woodpecker.User, error)) *MockClient_Self_Call {
	_c.Call.Return(run)
	return _c
}

// SetAddress provides a mock function for the type MockClient
func (_mock *MockClient) SetAddress(s string) {
	_mock.Called(s)
	return
}

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

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

func (_c *MockClient_SetAddress_Call) Run(run func(s string)) *MockClient_SetAddress_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 *MockClient_SetAddress_Call) Return() *MockClient_SetAddress_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockClient_SetAddress_Call) RunAndReturn(run func(s string)) *MockClient_SetAddress_Call {
	_c.Run(run)
	return _c
}

// SetClient provides a mock function for the type MockClient
func (_mock *MockClient) SetClient(client *http.Client) {
	_mock.Called(client)
	return
}

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

// SetClient is a helper method to define mock.On call
//   - client *http.Client
func (_e *MockClient_Expecter) SetClient(client interface{}) *MockClient_SetClient_Call {
	return &MockClient_SetClient_Call{Call: _e.mock.On("SetClient", client)}
}

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

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

func (_c *MockClient_SetClient_Call) RunAndReturn(run func(client *http.Client)) *MockClient_SetClient_Call {
	_c.Run(run)
	return _c
}

// SetLogLevel provides a mock function for the type MockClient
func (_mock *MockClient) SetLogLevel(logLevel *woodpecker.LogLevel) (*woodpecker.LogLevel, error) {
	ret := _mock.Called(logLevel)

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

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

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

// SetLogLevel is a helper method to define mock.On call
//   - logLevel *woodpecker.LogLevel
func (_e *MockClient_Expecter) SetLogLevel(logLevel interface{}) *MockClient_SetLogLevel_Call {
	return &MockClient_SetLogLevel_Call{Call: _e.mock.On("SetLogLevel", logLevel)}
}

func (_c *MockClient_SetLogLevel_Call) Run(run func(logLevel *woodpecker.LogLevel)) *MockClient_SetLogLevel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.LogLevel
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.LogLevel)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_SetLogLevel_Call) Return(logLevel1 *woodpecker.LogLevel, err error) *MockClient_SetLogLevel_Call {
	_c.Call.Return(logLevel1, err)
	return _c
}

func (_c *MockClient_SetLogLevel_Call) RunAndReturn(run func(logLevel *woodpecker.LogLevel) (*woodpecker.LogLevel, error)) *MockClient_SetLogLevel_Call {
	_c.Call.Return(run)
	return _c
}

// StepLogEntries provides a mock function for the type MockClient
func (_mock *MockClient) StepLogEntries(repoID int64, pipeline int64, stepID int64) ([]*woodpecker.LogEntry, error) {
	ret := _mock.Called(repoID, pipeline, stepID)

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

	var r0 []*woodpecker.LogEntry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int64, int64, int64) ([]*woodpecker.LogEntry, error)); ok {
		return returnFunc(repoID, pipeline, stepID)
	}
	if returnFunc, ok := ret.Get(0).(func(int64, int64, int64) []*woodpecker.LogEntry); ok {
		r0 = returnFunc(repoID, pipeline, stepID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.LogEntry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int64, int64, int64) error); ok {
		r1 = returnFunc(repoID, pipeline, stepID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// StepLogEntries is a helper method to define mock.On call
//   - repoID int64
//   - pipeline int64
//   - stepID int64
func (_e *MockClient_Expecter) StepLogEntries(repoID interface{}, pipeline interface{}, stepID interface{}) *MockClient_StepLogEntries_Call {
	return &MockClient_StepLogEntries_Call{Call: _e.mock.On("StepLogEntries", repoID, pipeline, stepID)}
}

func (_c *MockClient_StepLogEntries_Call) Run(run func(repoID int64, pipeline int64, stepID int64)) *MockClient_StepLogEntries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 int64
		if args[2] != nil {
			arg2 = args[2].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockClient_StepLogEntries_Call) Return(logEntrys []*woodpecker.LogEntry, err error) *MockClient_StepLogEntries_Call {
	_c.Call.Return(logEntrys, err)
	return _c
}

func (_c *MockClient_StepLogEntries_Call) RunAndReturn(run func(repoID int64, pipeline int64, stepID int64) ([]*woodpecker.LogEntry, error)) *MockClient_StepLogEntries_Call {
	_c.Call.Return(run)
	return _c
}

// StepLogsPurge provides a mock function for the type MockClient
func (_mock *MockClient) StepLogsPurge(repoID int64, pipelineNumber int64, stepID int64) error {
	ret := _mock.Called(repoID, pipelineNumber, stepID)

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

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

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

// StepLogsPurge is a helper method to define mock.On call
//   - repoID int64
//   - pipelineNumber int64
//   - stepID int64
func (_e *MockClient_Expecter) StepLogsPurge(repoID interface{}, pipelineNumber interface{}, stepID interface{}) *MockClient_StepLogsPurge_Call {
	return &MockClient_StepLogsPurge_Call{Call: _e.mock.On("StepLogsPurge", repoID, pipelineNumber, stepID)}
}

func (_c *MockClient_StepLogsPurge_Call) Run(run func(repoID int64, pipelineNumber int64, stepID int64)) *MockClient_StepLogsPurge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int64
		if args[0] != nil {
			arg0 = args[0].(int64)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 int64
		if args[2] != nil {
			arg2 = args[2].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockClient_StepLogsPurge_Call) RunAndReturn(run func(repoID int64, pipelineNumber int64, stepID int64) error) *MockClient_StepLogsPurge_Call {
	_c.Call.Return(run)
	return _c
}

// User provides a mock function for the type MockClient
func (_mock *MockClient) User(login string, forgeID ...int64) (*woodpecker.User, error) {
	var tmpRet mock.Arguments
	if len(forgeID) > 0 {
		tmpRet = _mock.Called(login, forgeID)
	} else {
		tmpRet = _mock.Called(login)
	}
	ret := tmpRet

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

	var r0 *woodpecker.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, ...int64) (*woodpecker.User, error)); ok {
		return returnFunc(login, forgeID...)
	}
	if returnFunc, ok := ret.Get(0).(func(string, ...int64) *woodpecker.User); ok {
		r0 = returnFunc(login, forgeID...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*woodpecker.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, ...int64) error); ok {
		r1 = returnFunc(login, forgeID...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// User is a helper method to define mock.On call
//   - login string
//   - forgeID ...int64
func (_e *MockClient_Expecter) User(login interface{}, forgeID ...interface{}) *MockClient_User_Call {
	return &MockClient_User_Call{Call: _e.mock.On("User",
		append([]interface{}{login}, forgeID...)...)}
}

func (_c *MockClient_User_Call) Run(run func(login string, forgeID ...int64)) *MockClient_User_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []int64
		var variadicArgs []int64
		if len(args) > 1 {
			variadicArgs = args[1].([]int64)
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockClient_User_Call) Return(user *woodpecker.User, err error) *MockClient_User_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *MockClient_User_Call) RunAndReturn(run func(login string, forgeID ...int64) (*woodpecker.User, error)) *MockClient_User_Call {
	_c.Call.Return(run)
	return _c
}

// UserDel provides a mock function for the type MockClient
func (_mock *MockClient) UserDel(login string, forgeID ...int64) error {
	var tmpRet mock.Arguments
	if len(forgeID) > 0 {
		tmpRet = _mock.Called(login, forgeID)
	} else {
		tmpRet = _mock.Called(login)
	}
	ret := tmpRet

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

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

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

// UserDel is a helper method to define mock.On call
//   - login string
//   - forgeID ...int64
func (_e *MockClient_Expecter) UserDel(login interface{}, forgeID ...interface{}) *MockClient_UserDel_Call {
	return &MockClient_UserDel_Call{Call: _e.mock.On("UserDel",
		append([]interface{}{login}, forgeID...)...)}
}

func (_c *MockClient_UserDel_Call) Run(run func(login string, forgeID ...int64)) *MockClient_UserDel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []int64
		var variadicArgs []int64
		if len(args) > 1 {
			variadicArgs = args[1].([]int64)
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockClient_UserDel_Call) RunAndReturn(run func(login string, forgeID ...int64) error) *MockClient_UserDel_Call {
	_c.Call.Return(run)
	return _c
}

// UserList provides a mock function for the type MockClient
func (_mock *MockClient) UserList(opt woodpecker.UserListOptions) ([]*woodpecker.User, error) {
	ret := _mock.Called(opt)

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

	var r0 []*woodpecker.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(woodpecker.UserListOptions) ([]*woodpecker.User, error)); ok {
		return returnFunc(opt)
	}
	if returnFunc, ok := ret.Get(0).(func(woodpecker.UserListOptions) []*woodpecker.User); ok {
		r0 = returnFunc(opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*woodpecker.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(woodpecker.UserListOptions) error); ok {
		r1 = returnFunc(opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserList is a helper method to define mock.On call
//   - opt woodpecker.UserListOptions
func (_e *MockClient_Expecter) UserList(opt interface{}) *MockClient_UserList_Call {
	return &MockClient_UserList_Call{Call: _e.mock.On("UserList", opt)}
}

func (_c *MockClient_UserList_Call) Run(run func(opt woodpecker.UserListOptions)) *MockClient_UserList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 woodpecker.UserListOptions
		if args[0] != nil {
			arg0 = args[0].(woodpecker.UserListOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_UserList_Call) Return(users []*woodpecker.User, err error) *MockClient_UserList_Call {
	_c.Call.Return(users, err)
	return _c
}

func (_c *MockClient_UserList_Call) RunAndReturn(run func(opt woodpecker.UserListOptions) ([]*woodpecker.User, error)) *MockClient_UserList_Call {
	_c.Call.Return(run)
	return _c
}

// UserPatch provides a mock function for the type MockClient
func (_mock *MockClient) UserPatch(user *woodpecker.User) (*woodpecker.User, error) {
	ret := _mock.Called(user)

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

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

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

// UserPatch is a helper method to define mock.On call
//   - user *woodpecker.User
func (_e *MockClient_Expecter) UserPatch(user interface{}) *MockClient_UserPatch_Call {
	return &MockClient_UserPatch_Call{Call: _e.mock.On("UserPatch", user)}
}

func (_c *MockClient_UserPatch_Call) Run(run func(user *woodpecker.User)) *MockClient_UserPatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.User
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.User)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_UserPatch_Call) Return(user1 *woodpecker.User, err error) *MockClient_UserPatch_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *MockClient_UserPatch_Call) RunAndReturn(run func(user *woodpecker.User) (*woodpecker.User, error)) *MockClient_UserPatch_Call {
	_c.Call.Return(run)
	return _c
}

// UserPost provides a mock function for the type MockClient
func (_mock *MockClient) UserPost(user *woodpecker.User) (*woodpecker.User, error) {
	ret := _mock.Called(user)

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

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

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

// UserPost is a helper method to define mock.On call
//   - user *woodpecker.User
func (_e *MockClient_Expecter) UserPost(user interface{}) *MockClient_UserPost_Call {
	return &MockClient_UserPost_Call{Call: _e.mock.On("UserPost", user)}
}

func (_c *MockClient_UserPost_Call) Run(run func(user *woodpecker.User)) *MockClient_UserPost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *woodpecker.User
		if args[0] != nil {
			arg0 = args[0].(*woodpecker.User)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_UserPost_Call) Return(user1 *woodpecker.User, err error) *MockClient_UserPost_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *MockClient_UserPost_Call) RunAndReturn(run func(user *woodpecker.User) (*woodpecker.User, error)) *MockClient_UserPost_Call {
	_c.Call.Return(run)
	return _c
}
