crow/server/store/mocks/mock_Store.go

// Code generated by mockery v2.53.0. DO NOT EDIT.

package store

import (
	context "context"

	model "codeberg.org/crowci/crow/v3/server/model"
	mock "github.com/stretchr/testify/mock"
)

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

type MockStore_Expecter struct {
	mock *mock.Mock
}

func (_m *MockStore) EXPECT() *MockStore_Expecter {
	return &MockStore_Expecter{mock: &_m.Mock}
}

// AgentCreate provides a mock function with given fields: _a0
func (_m *MockStore) AgentCreate(_a0 *model.Agent) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AgentCreate is a helper method to define mock.On call
//   - _a0 *model.Agent
func (_e *MockStore_Expecter) AgentCreate(_a0 interface{}) *MockStore_AgentCreate_Call {
	return &MockStore_AgentCreate_Call{Call: _e.mock.On("AgentCreate", _a0)}
}

func (_c *MockStore_AgentCreate_Call) Run(run func(_a0 *model.Agent)) *MockStore_AgentCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Agent))
	})
	return _c
}

func (_c *MockStore_AgentCreate_Call) Return(_a0 error) *MockStore_AgentCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_AgentCreate_Call) RunAndReturn(run func(*model.Agent) error) *MockStore_AgentCreate_Call {
	_c.Call.Return(run)
	return _c
}

// AgentDelete provides a mock function with given fields: _a0
func (_m *MockStore) AgentDelete(_a0 *model.Agent) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AgentDelete is a helper method to define mock.On call
//   - _a0 *model.Agent
func (_e *MockStore_Expecter) AgentDelete(_a0 interface{}) *MockStore_AgentDelete_Call {
	return &MockStore_AgentDelete_Call{Call: _e.mock.On("AgentDelete", _a0)}
}

func (_c *MockStore_AgentDelete_Call) Run(run func(_a0 *model.Agent)) *MockStore_AgentDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Agent))
	})
	return _c
}

func (_c *MockStore_AgentDelete_Call) Return(_a0 error) *MockStore_AgentDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_AgentDelete_Call) RunAndReturn(run func(*model.Agent) error) *MockStore_AgentDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AgentFind provides a mock function with given fields: _a0
func (_m *MockStore) AgentFind(_a0 int64) (*model.Agent, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Agent
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Agent, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Agent); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Agent)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AgentFind is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) AgentFind(_a0 interface{}) *MockStore_AgentFind_Call {
	return &MockStore_AgentFind_Call{Call: _e.mock.On("AgentFind", _a0)}
}

func (_c *MockStore_AgentFind_Call) Run(run func(_a0 int64)) *MockStore_AgentFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_AgentFind_Call) Return(_a0 *model.Agent, _a1 error) *MockStore_AgentFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_AgentFind_Call) RunAndReturn(run func(int64) (*model.Agent, error)) *MockStore_AgentFind_Call {
	_c.Call.Return(run)
	return _c
}

// AgentFindByToken provides a mock function with given fields: _a0
func (_m *MockStore) AgentFindByToken(_a0 string) (*model.Agent, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Agent
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*model.Agent, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(string) *model.Agent); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Agent)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AgentFindByToken is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) AgentFindByToken(_a0 interface{}) *MockStore_AgentFindByToken_Call {
	return &MockStore_AgentFindByToken_Call{Call: _e.mock.On("AgentFindByToken", _a0)}
}

func (_c *MockStore_AgentFindByToken_Call) Run(run func(_a0 string)) *MockStore_AgentFindByToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_AgentFindByToken_Call) Return(_a0 *model.Agent, _a1 error) *MockStore_AgentFindByToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// AgentList provides a mock function with given fields: p
func (_m *MockStore) AgentList(p *model.ListOptions) ([]*model.Agent, error) {
	ret := _m.Called(p)

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

	var r0 []*model.Agent
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Agent, error)); ok {
		return rf(p)
	}
	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Agent); ok {
		r0 = rf(p)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Agent)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = rf(p)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AgentList is a helper method to define mock.On call
//   - p *model.ListOptions
func (_e *MockStore_Expecter) AgentList(p interface{}) *MockStore_AgentList_Call {
	return &MockStore_AgentList_Call{Call: _e.mock.On("AgentList", p)}
}

func (_c *MockStore_AgentList_Call) Run(run func(p *model.ListOptions)) *MockStore_AgentList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_AgentList_Call) Return(_a0 []*model.Agent, _a1 error) *MockStore_AgentList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_AgentList_Call) RunAndReturn(run func(*model.ListOptions) ([]*model.Agent, error)) *MockStore_AgentList_Call {
	_c.Call.Return(run)
	return _c
}

// AgentListForOrg provides a mock function with given fields: orgID, opt
func (_m *MockStore) AgentListForOrg(orgID int64, opt *model.ListOptions) ([]*model.Agent, error) {
	ret := _m.Called(orgID, opt)

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

	var r0 []*model.Agent
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Agent, error)); ok {
		return rf(orgID, opt)
	}
	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Agent); ok {
		r0 = rf(orgID, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Agent)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
		r1 = rf(orgID, opt)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AgentListForOrg is a helper method to define mock.On call
//   - orgID int64
//   - opt *model.ListOptions
func (_e *MockStore_Expecter) AgentListForOrg(orgID interface{}, opt interface{}) *MockStore_AgentListForOrg_Call {
	return &MockStore_AgentListForOrg_Call{Call: _e.mock.On("AgentListForOrg", orgID, opt)}
}

func (_c *MockStore_AgentListForOrg_Call) Run(run func(orgID int64, opt *model.ListOptions)) *MockStore_AgentListForOrg_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_AgentListForOrg_Call) Return(_a0 []*model.Agent, _a1 error) *MockStore_AgentListForOrg_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_AgentListForOrg_Call) RunAndReturn(run func(int64, *model.ListOptions) ([]*model.Agent, error)) *MockStore_AgentListForOrg_Call {
	_c.Call.Return(run)
	return _c
}

// AgentUpdate provides a mock function with given fields: _a0
func (_m *MockStore) AgentUpdate(_a0 *model.Agent) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AgentUpdate is a helper method to define mock.On call
//   - _a0 *model.Agent
func (_e *MockStore_Expecter) AgentUpdate(_a0 interface{}) *MockStore_AgentUpdate_Call {
	return &MockStore_AgentUpdate_Call{Call: _e.mock.On("AgentUpdate", _a0)}
}

func (_c *MockStore_AgentUpdate_Call) Run(run func(_a0 *model.Agent)) *MockStore_AgentUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Agent))
	})
	return _c
}

func (_c *MockStore_AgentUpdate_Call) Return(_a0 error) *MockStore_AgentUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_AgentUpdate_Call) RunAndReturn(run func(*model.Agent) error) *MockStore_AgentUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function with no fields
func (_m *MockStore) Close() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Close is a helper method to define mock.On call
func (_e *MockStore_Expecter) Close() *MockStore_Close_Call {
	return &MockStore_Close_Call{Call: _e.mock.On("Close")}
}

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

func (_c *MockStore_Close_Call) Return(_a0 error) *MockStore_Close_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_Close_Call) RunAndReturn(run func() error) *MockStore_Close_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigPersist provides a mock function with given fields: _a0
func (_m *MockStore) ConfigPersist(_a0 *model.Config) (*model.Config, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Config
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Config) (*model.Config, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.Config) *model.Config); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Config)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Config) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ConfigPersist is a helper method to define mock.On call
//   - _a0 *model.Config
func (_e *MockStore_Expecter) ConfigPersist(_a0 interface{}) *MockStore_ConfigPersist_Call {
	return &MockStore_ConfigPersist_Call{Call: _e.mock.On("ConfigPersist", _a0)}
}

func (_c *MockStore_ConfigPersist_Call) Run(run func(_a0 *model.Config)) *MockStore_ConfigPersist_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Config))
	})
	return _c
}

func (_c *MockStore_ConfigPersist_Call) Return(_a0 *model.Config, _a1 error) *MockStore_ConfigPersist_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_ConfigPersist_Call) RunAndReturn(run func(*model.Config) (*model.Config, error)) *MockStore_ConfigPersist_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigsForPipeline provides a mock function with given fields: pipelineID
func (_m *MockStore) ConfigsForPipeline(pipelineID int64) ([]*model.Config, error) {
	ret := _m.Called(pipelineID)

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

	var r0 []*model.Config
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) ([]*model.Config, error)); ok {
		return rf(pipelineID)
	}
	if rf, ok := ret.Get(0).(func(int64) []*model.Config); ok {
		r0 = rf(pipelineID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Config)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(pipelineID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ConfigsForPipeline is a helper method to define mock.On call
//   - pipelineID int64
func (_e *MockStore_Expecter) ConfigsForPipeline(pipelineID interface{}) *MockStore_ConfigsForPipeline_Call {
	return &MockStore_ConfigsForPipeline_Call{Call: _e.mock.On("ConfigsForPipeline", pipelineID)}
}

func (_c *MockStore_ConfigsForPipeline_Call) Run(run func(pipelineID int64)) *MockStore_ConfigsForPipeline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_ConfigsForPipeline_Call) Return(_a0 []*model.Config, _a1 error) *MockStore_ConfigsForPipeline_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_ConfigsForPipeline_Call) RunAndReturn(run func(int64) ([]*model.Config, error)) *MockStore_ConfigsForPipeline_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePipeline provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CreatePipeline(_a0 *model.Pipeline, _a1 ...*model.Step) error {
	_va := make([]interface{}, len(_a1))
	for _i := range _a1 {
		_va[_i] = _a1[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline, ...*model.Step) error); ok {
		r0 = rf(_a0, _a1...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreatePipeline is a helper method to define mock.On call
//   - _a0 *model.Pipeline
//   - _a1 ...*model.Step
func (_e *MockStore_Expecter) CreatePipeline(_a0 interface{}, _a1 ...interface{}) *MockStore_CreatePipeline_Call {
	return &MockStore_CreatePipeline_Call{Call: _e.mock.On("CreatePipeline",
		append([]interface{}{_a0}, _a1...)...)}
}

func (_c *MockStore_CreatePipeline_Call) Run(run func(_a0 *model.Pipeline, _a1 ...*model.Step)) *MockStore_CreatePipeline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*model.Step, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(*model.Step)
			}
		}
		run(args[0].(*model.Pipeline), variadicArgs...)
	})
	return _c
}

func (_c *MockStore_CreatePipeline_Call) Return(_a0 error) *MockStore_CreatePipeline_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CreatePipeline_Call) RunAndReturn(run func(*model.Pipeline, ...*model.Step) error) *MockStore_CreatePipeline_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRedirection provides a mock function with given fields: redirection
func (_m *MockStore) CreateRedirection(redirection *model.Redirection) error {
	ret := _m.Called(redirection)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Redirection) error); ok {
		r0 = rf(redirection)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreateRedirection is a helper method to define mock.On call
//   - redirection *model.Redirection
func (_e *MockStore_Expecter) CreateRedirection(redirection interface{}) *MockStore_CreateRedirection_Call {
	return &MockStore_CreateRedirection_Call{Call: _e.mock.On("CreateRedirection", redirection)}
}

func (_c *MockStore_CreateRedirection_Call) Run(run func(redirection *model.Redirection)) *MockStore_CreateRedirection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Redirection))
	})
	return _c
}

func (_c *MockStore_CreateRedirection_Call) Return(_a0 error) *MockStore_CreateRedirection_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CreateRedirection_Call) RunAndReturn(run func(*model.Redirection) error) *MockStore_CreateRedirection_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRepo provides a mock function with given fields: _a0
func (_m *MockStore) CreateRepo(_a0 *model.Repo) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreateRepo is a helper method to define mock.On call
//   - _a0 *model.Repo
func (_e *MockStore_Expecter) CreateRepo(_a0 interface{}) *MockStore_CreateRepo_Call {
	return &MockStore_CreateRepo_Call{Call: _e.mock.On("CreateRepo", _a0)}
}

func (_c *MockStore_CreateRepo_Call) Run(run func(_a0 *model.Repo)) *MockStore_CreateRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo))
	})
	return _c
}

func (_c *MockStore_CreateRepo_Call) Return(_a0 error) *MockStore_CreateRepo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CreateRepo_Call) RunAndReturn(run func(*model.Repo) error) *MockStore_CreateRepo_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUser provides a mock function with given fields: _a0
func (_m *MockStore) CreateUser(_a0 *model.User) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.User) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CreateUser is a helper method to define mock.On call
//   - _a0 *model.User
func (_e *MockStore_Expecter) CreateUser(_a0 interface{}) *MockStore_CreateUser_Call {
	return &MockStore_CreateUser_Call{Call: _e.mock.On("CreateUser", _a0)}
}

func (_c *MockStore_CreateUser_Call) Run(run func(_a0 *model.User)) *MockStore_CreateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User))
	})
	return _c
}

func (_c *MockStore_CreateUser_Call) Return(_a0 error) *MockStore_CreateUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CreateUser_Call) RunAndReturn(run func(*model.User) error) *MockStore_CreateUser_Call {
	_c.Call.Return(run)
	return _c
}

// CronCreate provides a mock function with given fields: _a0
func (_m *MockStore) CronCreate(_a0 *model.Cron) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Cron) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CronCreate is a helper method to define mock.On call
//   - _a0 *model.Cron
func (_e *MockStore_Expecter) CronCreate(_a0 interface{}) *MockStore_CronCreate_Call {
	return &MockStore_CronCreate_Call{Call: _e.mock.On("CronCreate", _a0)}
}

func (_c *MockStore_CronCreate_Call) Run(run func(_a0 *model.Cron)) *MockStore_CronCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Cron))
	})
	return _c
}

func (_c *MockStore_CronCreate_Call) Return(_a0 error) *MockStore_CronCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CronCreate_Call) RunAndReturn(run func(*model.Cron) error) *MockStore_CronCreate_Call {
	_c.Call.Return(run)
	return _c
}

// CronDelete provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CronDelete(_a0 *model.Repo, _a1 int64) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Repo, int64) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CronDelete is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 int64
func (_e *MockStore_Expecter) CronDelete(_a0 interface{}, _a1 interface{}) *MockStore_CronDelete_Call {
	return &MockStore_CronDelete_Call{Call: _e.mock.On("CronDelete", _a0, _a1)}
}

func (_c *MockStore_CronDelete_Call) Run(run func(_a0 *model.Repo, _a1 int64)) *MockStore_CronDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(int64))
	})
	return _c
}

func (_c *MockStore_CronDelete_Call) Return(_a0 error) *MockStore_CronDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CronDelete_Call) RunAndReturn(run func(*model.Repo, int64) error) *MockStore_CronDelete_Call {
	_c.Call.Return(run)
	return _c
}

// CronFind provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CronFind(_a0 *model.Repo, _a1 int64) (*model.Cron, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Cron
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, int64) (*model.Cron, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, int64) *model.Cron); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Cron)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, int64) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CronFind is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 int64
func (_e *MockStore_Expecter) CronFind(_a0 interface{}, _a1 interface{}) *MockStore_CronFind_Call {
	return &MockStore_CronFind_Call{Call: _e.mock.On("CronFind", _a0, _a1)}
}

func (_c *MockStore_CronFind_Call) Run(run func(_a0 *model.Repo, _a1 int64)) *MockStore_CronFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(int64))
	})
	return _c
}

func (_c *MockStore_CronFind_Call) Return(_a0 *model.Cron, _a1 error) *MockStore_CronFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_CronFind_Call) RunAndReturn(run func(*model.Repo, int64) (*model.Cron, error)) *MockStore_CronFind_Call {
	_c.Call.Return(run)
	return _c
}

// CronGetLock provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CronGetLock(_a0 *model.Cron, _a1 int64) (bool, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Cron, int64) (bool, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Cron, int64) bool); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(*model.Cron, int64) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CronGetLock is a helper method to define mock.On call
//   - _a0 *model.Cron
//   - _a1 int64
func (_e *MockStore_Expecter) CronGetLock(_a0 interface{}, _a1 interface{}) *MockStore_CronGetLock_Call {
	return &MockStore_CronGetLock_Call{Call: _e.mock.On("CronGetLock", _a0, _a1)}
}

func (_c *MockStore_CronGetLock_Call) Run(run func(_a0 *model.Cron, _a1 int64)) *MockStore_CronGetLock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Cron), args[1].(int64))
	})
	return _c
}

func (_c *MockStore_CronGetLock_Call) Return(_a0 bool, _a1 error) *MockStore_CronGetLock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_CronGetLock_Call) RunAndReturn(run func(*model.Cron, int64) (bool, error)) *MockStore_CronGetLock_Call {
	_c.Call.Return(run)
	return _c
}

// CronList provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CronList(_a0 *model.Repo, _a1 *model.ListOptions) ([]*model.Cron, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 []*model.Cron
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Cron, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Cron); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Cron)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CronList is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 *model.ListOptions
func (_e *MockStore_Expecter) CronList(_a0 interface{}, _a1 interface{}) *MockStore_CronList_Call {
	return &MockStore_CronList_Call{Call: _e.mock.On("CronList", _a0, _a1)}
}

func (_c *MockStore_CronList_Call) Run(run func(_a0 *model.Repo, _a1 *model.ListOptions)) *MockStore_CronList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_CronList_Call) Return(_a0 []*model.Cron, _a1 error) *MockStore_CronList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_CronList_Call) RunAndReturn(run func(*model.Repo, *model.ListOptions) ([]*model.Cron, error)) *MockStore_CronList_Call {
	_c.Call.Return(run)
	return _c
}

// CronListNextExecute provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CronListNextExecute(_a0 int64, _a1 int64) ([]*model.Cron, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 []*model.Cron
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, int64) ([]*model.Cron, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(int64, int64) []*model.Cron); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Cron)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CronListNextExecute is a helper method to define mock.On call
//   - _a0 int64
//   - _a1 int64
func (_e *MockStore_Expecter) CronListNextExecute(_a0 interface{}, _a1 interface{}) *MockStore_CronListNextExecute_Call {
	return &MockStore_CronListNextExecute_Call{Call: _e.mock.On("CronListNextExecute", _a0, _a1)}
}

func (_c *MockStore_CronListNextExecute_Call) Run(run func(_a0 int64, _a1 int64)) *MockStore_CronListNextExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(int64))
	})
	return _c
}

func (_c *MockStore_CronListNextExecute_Call) Return(_a0 []*model.Cron, _a1 error) *MockStore_CronListNextExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_CronListNextExecute_Call) RunAndReturn(run func(int64, int64) ([]*model.Cron, error)) *MockStore_CronListNextExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CronUpdate provides a mock function with given fields: _a0, _a1
func (_m *MockStore) CronUpdate(_a0 *model.Repo, _a1 *model.Cron) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Repo, *model.Cron) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CronUpdate is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 *model.Cron
func (_e *MockStore_Expecter) CronUpdate(_a0 interface{}, _a1 interface{}) *MockStore_CronUpdate_Call {
	return &MockStore_CronUpdate_Call{Call: _e.mock.On("CronUpdate", _a0, _a1)}
}

func (_c *MockStore_CronUpdate_Call) Run(run func(_a0 *model.Repo, _a1 *model.Cron)) *MockStore_CronUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(*model.Cron))
	})
	return _c
}

func (_c *MockStore_CronUpdate_Call) Return(_a0 error) *MockStore_CronUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_CronUpdate_Call) RunAndReturn(run func(*model.Repo, *model.Cron) error) *MockStore_CronUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePipeline provides a mock function with given fields: _a0
func (_m *MockStore) DeletePipeline(_a0 *model.Pipeline) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeletePipeline is a helper method to define mock.On call
//   - _a0 *model.Pipeline
func (_e *MockStore_Expecter) DeletePipeline(_a0 interface{}) *MockStore_DeletePipeline_Call {
	return &MockStore_DeletePipeline_Call{Call: _e.mock.On("DeletePipeline", _a0)}
}

func (_c *MockStore_DeletePipeline_Call) Run(run func(_a0 *model.Pipeline)) *MockStore_DeletePipeline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline))
	})
	return _c
}

func (_c *MockStore_DeletePipeline_Call) Return(_a0 error) *MockStore_DeletePipeline_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_DeletePipeline_Call) RunAndReturn(run func(*model.Pipeline) error) *MockStore_DeletePipeline_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRepo provides a mock function with given fields: _a0
func (_m *MockStore) DeleteRepo(_a0 *model.Repo) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteRepo is a helper method to define mock.On call
//   - _a0 *model.Repo
func (_e *MockStore_Expecter) DeleteRepo(_a0 interface{}) *MockStore_DeleteRepo_Call {
	return &MockStore_DeleteRepo_Call{Call: _e.mock.On("DeleteRepo", _a0)}
}

func (_c *MockStore_DeleteRepo_Call) Run(run func(_a0 *model.Repo)) *MockStore_DeleteRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo))
	})
	return _c
}

func (_c *MockStore_DeleteRepo_Call) Return(_a0 error) *MockStore_DeleteRepo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_DeleteRepo_Call) RunAndReturn(run func(*model.Repo) error) *MockStore_DeleteRepo_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUser provides a mock function with given fields: _a0
func (_m *MockStore) DeleteUser(_a0 *model.User) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.User) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteUser is a helper method to define mock.On call
//   - _a0 *model.User
func (_e *MockStore_Expecter) DeleteUser(_a0 interface{}) *MockStore_DeleteUser_Call {
	return &MockStore_DeleteUser_Call{Call: _e.mock.On("DeleteUser", _a0)}
}

func (_c *MockStore_DeleteUser_Call) Run(run func(_a0 *model.User)) *MockStore_DeleteUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User))
	})
	return _c
}

func (_c *MockStore_DeleteUser_Call) Return(_a0 error) *MockStore_DeleteUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_DeleteUser_Call) RunAndReturn(run func(*model.User) error) *MockStore_DeleteUser_Call {
	_c.Call.Return(run)
	return _c
}

// ForgeCreate provides a mock function with given fields: _a0
func (_m *MockStore) ForgeCreate(_a0 *model.Forge) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ForgeCreate is a helper method to define mock.On call
//   - _a0 *model.Forge
func (_e *MockStore_Expecter) ForgeCreate(_a0 interface{}) *MockStore_ForgeCreate_Call {
	return &MockStore_ForgeCreate_Call{Call: _e.mock.On("ForgeCreate", _a0)}
}

func (_c *MockStore_ForgeCreate_Call) Run(run func(_a0 *model.Forge)) *MockStore_ForgeCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Forge))
	})
	return _c
}

func (_c *MockStore_ForgeCreate_Call) Return(_a0 error) *MockStore_ForgeCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_ForgeCreate_Call) RunAndReturn(run func(*model.Forge) error) *MockStore_ForgeCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ForgeDelete provides a mock function with given fields: _a0
func (_m *MockStore) ForgeDelete(_a0 *model.Forge) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ForgeDelete is a helper method to define mock.On call
//   - _a0 *model.Forge
func (_e *MockStore_Expecter) ForgeDelete(_a0 interface{}) *MockStore_ForgeDelete_Call {
	return &MockStore_ForgeDelete_Call{Call: _e.mock.On("ForgeDelete", _a0)}
}

func (_c *MockStore_ForgeDelete_Call) Run(run func(_a0 *model.Forge)) *MockStore_ForgeDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Forge))
	})
	return _c
}

func (_c *MockStore_ForgeDelete_Call) Return(_a0 error) *MockStore_ForgeDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_ForgeDelete_Call) RunAndReturn(run func(*model.Forge) error) *MockStore_ForgeDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ForgeGet provides a mock function with given fields: _a0
func (_m *MockStore) ForgeGet(_a0 int64) (*model.Forge, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Forge
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Forge, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Forge); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Forge)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ForgeGet is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) ForgeGet(_a0 interface{}) *MockStore_ForgeGet_Call {
	return &MockStore_ForgeGet_Call{Call: _e.mock.On("ForgeGet", _a0)}
}

func (_c *MockStore_ForgeGet_Call) Run(run func(_a0 int64)) *MockStore_ForgeGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_ForgeGet_Call) Return(_a0 *model.Forge, _a1 error) *MockStore_ForgeGet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_ForgeGet_Call) RunAndReturn(run func(int64) (*model.Forge, error)) *MockStore_ForgeGet_Call {
	_c.Call.Return(run)
	return _c
}

// ForgeList provides a mock function with given fields: p
func (_m *MockStore) ForgeList(p *model.ListOptions) ([]*model.Forge, error) {
	ret := _m.Called(p)

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

	var r0 []*model.Forge
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Forge, error)); ok {
		return rf(p)
	}
	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Forge); ok {
		r0 = rf(p)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Forge)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = rf(p)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ForgeList is a helper method to define mock.On call
//   - p *model.ListOptions
func (_e *MockStore_Expecter) ForgeList(p interface{}) *MockStore_ForgeList_Call {
	return &MockStore_ForgeList_Call{Call: _e.mock.On("ForgeList", p)}
}

func (_c *MockStore_ForgeList_Call) Run(run func(p *model.ListOptions)) *MockStore_ForgeList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_ForgeList_Call) Return(_a0 []*model.Forge, _a1 error) *MockStore_ForgeList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_ForgeList_Call) RunAndReturn(run func(*model.ListOptions) ([]*model.Forge, error)) *MockStore_ForgeList_Call {
	_c.Call.Return(run)
	return _c
}

// ForgeUpdate provides a mock function with given fields: _a0
func (_m *MockStore) ForgeUpdate(_a0 *model.Forge) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ForgeUpdate is a helper method to define mock.On call
//   - _a0 *model.Forge
func (_e *MockStore_Expecter) ForgeUpdate(_a0 interface{}) *MockStore_ForgeUpdate_Call {
	return &MockStore_ForgeUpdate_Call{Call: _e.mock.On("ForgeUpdate", _a0)}
}

func (_c *MockStore_ForgeUpdate_Call) Run(run func(_a0 *model.Forge)) *MockStore_ForgeUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Forge))
	})
	return _c
}

func (_c *MockStore_ForgeUpdate_Call) Return(_a0 error) *MockStore_ForgeUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_ForgeUpdate_Call) RunAndReturn(run func(*model.Forge) error) *MockStore_ForgeUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// GetActivePipelineList provides a mock function with given fields: repo
func (_m *MockStore) GetActivePipelineList(repo *model.Repo) ([]*model.Pipeline, error) {
	ret := _m.Called(repo)

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

	var r0 []*model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo) ([]*model.Pipeline, error)); ok {
		return rf(repo)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo) []*model.Pipeline); ok {
		r0 = rf(repo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo) error); ok {
		r1 = rf(repo)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetActivePipelineList is a helper method to define mock.On call
//   - repo *model.Repo
func (_e *MockStore_Expecter) GetActivePipelineList(repo interface{}) *MockStore_GetActivePipelineList_Call {
	return &MockStore_GetActivePipelineList_Call{Call: _e.mock.On("GetActivePipelineList", repo)}
}

func (_c *MockStore_GetActivePipelineList_Call) Run(run func(repo *model.Repo)) *MockStore_GetActivePipelineList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo))
	})
	return _c
}

func (_c *MockStore_GetActivePipelineList_Call) Return(_a0 []*model.Pipeline, _a1 error) *MockStore_GetActivePipelineList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetActivePipelineList_Call) RunAndReturn(run func(*model.Repo) ([]*model.Pipeline, error)) *MockStore_GetActivePipelineList_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipeline provides a mock function with given fields: _a0
func (_m *MockStore) GetPipeline(_a0 int64) (*model.Pipeline, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Pipeline, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Pipeline); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipeline is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) GetPipeline(_a0 interface{}) *MockStore_GetPipeline_Call {
	return &MockStore_GetPipeline_Call{Call: _e.mock.On("GetPipeline", _a0)}
}

func (_c *MockStore_GetPipeline_Call) Run(run func(_a0 int64)) *MockStore_GetPipeline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_GetPipeline_Call) Return(_a0 *model.Pipeline, _a1 error) *MockStore_GetPipeline_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipeline_Call) RunAndReturn(run func(int64) (*model.Pipeline, error)) *MockStore_GetPipeline_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineBadge provides a mock function with given fields: _a0, _a1
func (_m *MockStore) GetPipelineBadge(_a0 *model.Repo, _a1 string) (*model.Pipeline, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Pipeline, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Pipeline); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineBadge is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 string
func (_e *MockStore_Expecter) GetPipelineBadge(_a0 interface{}, _a1 interface{}) *MockStore_GetPipelineBadge_Call {
	return &MockStore_GetPipelineBadge_Call{Call: _e.mock.On("GetPipelineBadge", _a0, _a1)}
}

func (_c *MockStore_GetPipelineBadge_Call) Run(run func(_a0 *model.Repo, _a1 string)) *MockStore_GetPipelineBadge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(string))
	})
	return _c
}

func (_c *MockStore_GetPipelineBadge_Call) Return(_a0 *model.Pipeline, _a1 error) *MockStore_GetPipelineBadge_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineBadge_Call) RunAndReturn(run func(*model.Repo, string) (*model.Pipeline, error)) *MockStore_GetPipelineBadge_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineCount provides a mock function with no fields
func (_m *MockStore) GetPipelineCount() (int64, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineCount is a helper method to define mock.On call
func (_e *MockStore_Expecter) GetPipelineCount() *MockStore_GetPipelineCount_Call {
	return &MockStore_GetPipelineCount_Call{Call: _e.mock.On("GetPipelineCount")}
}

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

func (_c *MockStore_GetPipelineCount_Call) Return(_a0 int64, _a1 error) *MockStore_GetPipelineCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetPipelineCountByRepo provides a mock function with given fields: _a0
func (_m *MockStore) GetPipelineCountByRepo(_a0 int64) (int64, error) {
	ret := _m.Called(_a0)

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

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

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineCountByRepo is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) GetPipelineCountByRepo(_a0 interface{}) *MockStore_GetPipelineCountByRepo_Call {
	return &MockStore_GetPipelineCountByRepo_Call{Call: _e.mock.On("GetPipelineCountByRepo", _a0)}
}

func (_c *MockStore_GetPipelineCountByRepo_Call) Run(run func(_a0 int64)) *MockStore_GetPipelineCountByRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_GetPipelineCountByRepo_Call) Return(_a0 int64, _a1 error) *MockStore_GetPipelineCountByRepo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetPipelineLast provides a mock function with given fields: _a0, _a1
func (_m *MockStore) GetPipelineLast(_a0 *model.Repo, _a1 string) (*model.Pipeline, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Pipeline, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Pipeline); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineLast is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 string
func (_e *MockStore_Expecter) GetPipelineLast(_a0 interface{}, _a1 interface{}) *MockStore_GetPipelineLast_Call {
	return &MockStore_GetPipelineLast_Call{Call: _e.mock.On("GetPipelineLast", _a0, _a1)}
}

func (_c *MockStore_GetPipelineLast_Call) Run(run func(_a0 *model.Repo, _a1 string)) *MockStore_GetPipelineLast_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(string))
	})
	return _c
}

func (_c *MockStore_GetPipelineLast_Call) Return(_a0 *model.Pipeline, _a1 error) *MockStore_GetPipelineLast_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineLast_Call) RunAndReturn(run func(*model.Repo, string) (*model.Pipeline, error)) *MockStore_GetPipelineLast_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineLastBefore provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockStore) GetPipelineLastBefore(_a0 *model.Repo, _a1 string, _a2 int64) (*model.Pipeline, error) {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 *model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, string, int64) (*model.Pipeline, error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, string, int64) *model.Pipeline); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, string, int64) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineLastBefore is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 string
//   - _a2 int64
func (_e *MockStore_Expecter) GetPipelineLastBefore(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockStore_GetPipelineLastBefore_Call {
	return &MockStore_GetPipelineLastBefore_Call{Call: _e.mock.On("GetPipelineLastBefore", _a0, _a1, _a2)}
}

func (_c *MockStore_GetPipelineLastBefore_Call) Run(run func(_a0 *model.Repo, _a1 string, _a2 int64)) *MockStore_GetPipelineLastBefore_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(string), args[2].(int64))
	})
	return _c
}

func (_c *MockStore_GetPipelineLastBefore_Call) Return(_a0 *model.Pipeline, _a1 error) *MockStore_GetPipelineLastBefore_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineLastBefore_Call) RunAndReturn(run func(*model.Repo, string, int64) (*model.Pipeline, error)) *MockStore_GetPipelineLastBefore_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineList provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockStore) GetPipelineList(_a0 *model.Repo, _a1 *model.ListOptions, _a2 *model.PipelineFilter) ([]*model.Pipeline, error) {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 []*model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) ([]*model.Pipeline, error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) []*model.Pipeline); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineList is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 *model.ListOptions
//   - _a2 *model.PipelineFilter
func (_e *MockStore_Expecter) GetPipelineList(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockStore_GetPipelineList_Call {
	return &MockStore_GetPipelineList_Call{Call: _e.mock.On("GetPipelineList", _a0, _a1, _a2)}
}

func (_c *MockStore_GetPipelineList_Call) Run(run func(_a0 *model.Repo, _a1 *model.ListOptions, _a2 *model.PipelineFilter)) *MockStore_GetPipelineList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(*model.ListOptions), args[2].(*model.PipelineFilter))
	})
	return _c
}

func (_c *MockStore_GetPipelineList_Call) Return(_a0 []*model.Pipeline, _a1 error) *MockStore_GetPipelineList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineList_Call) RunAndReturn(run func(*model.Repo, *model.ListOptions, *model.PipelineFilter) ([]*model.Pipeline, error)) *MockStore_GetPipelineList_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineListKeyset provides a mock function with given fields: repo, startID, beforeDate, limit
func (_m *MockStore) GetPipelineListKeyset(repo *model.Repo, startID int64, beforeDate int64, limit int) ([]*model.Pipeline, error) {
	ret := _m.Called(repo, startID, beforeDate, limit)

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

	var r0 []*model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, int64, int64, int) ([]*model.Pipeline, error)); ok {
		return rf(repo, startID, beforeDate, limit)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, int64, int64, int) []*model.Pipeline); ok {
		r0 = rf(repo, startID, beforeDate, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, int64, int64, int) error); ok {
		r1 = rf(repo, startID, beforeDate, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineListKeyset is a helper method to define mock.On call
//   - repo *model.Repo
//   - startID int64
//   - beforeDate int64
//   - limit int
func (_e *MockStore_Expecter) GetPipelineListKeyset(repo interface{}, startID interface{}, beforeDate interface{}, limit interface{}) *MockStore_GetPipelineListKeyset_Call {
	return &MockStore_GetPipelineListKeyset_Call{Call: _e.mock.On("GetPipelineListKeyset", repo, startID, beforeDate, limit)}
}

func (_c *MockStore_GetPipelineListKeyset_Call) Run(run func(repo *model.Repo, startID int64, beforeDate int64, limit int)) *MockStore_GetPipelineListKeyset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(int64), args[2].(int64), args[3].(int))
	})
	return _c
}

func (_c *MockStore_GetPipelineListKeyset_Call) Return(_a0 []*model.Pipeline, _a1 error) *MockStore_GetPipelineListKeyset_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineListKeyset_Call) RunAndReturn(run func(*model.Repo, int64, int64, int) ([]*model.Pipeline, error)) *MockStore_GetPipelineListKeyset_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineLogPurged provides a mock function with given fields: _a0
func (_m *MockStore) GetPipelineLogPurged(_a0 *model.Pipeline) (bool, error) {
	ret := _m.Called(_a0)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline) (bool, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.Pipeline) bool); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineLogPurged is a helper method to define mock.On call
//   - _a0 *model.Pipeline
func (_e *MockStore_Expecter) GetPipelineLogPurged(_a0 interface{}) *MockStore_GetPipelineLogPurged_Call {
	return &MockStore_GetPipelineLogPurged_Call{Call: _e.mock.On("GetPipelineLogPurged", _a0)}
}

func (_c *MockStore_GetPipelineLogPurged_Call) Run(run func(_a0 *model.Pipeline)) *MockStore_GetPipelineLogPurged_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline))
	})
	return _c
}

func (_c *MockStore_GetPipelineLogPurged_Call) Return(_a0 bool, _a1 error) *MockStore_GetPipelineLogPurged_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineLogPurged_Call) RunAndReturn(run func(*model.Pipeline) (bool, error)) *MockStore_GetPipelineLogPurged_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineNumber provides a mock function with given fields: _a0, _a1
func (_m *MockStore) GetPipelineNumber(_a0 *model.Repo, _a1 int64) (*model.Pipeline, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, int64) (*model.Pipeline, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, int64) *model.Pipeline); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, int64) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineNumber is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 int64
func (_e *MockStore_Expecter) GetPipelineNumber(_a0 interface{}, _a1 interface{}) *MockStore_GetPipelineNumber_Call {
	return &MockStore_GetPipelineNumber_Call{Call: _e.mock.On("GetPipelineNumber", _a0, _a1)}
}

func (_c *MockStore_GetPipelineNumber_Call) Run(run func(_a0 *model.Repo, _a1 int64)) *MockStore_GetPipelineNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(int64))
	})
	return _c
}

func (_c *MockStore_GetPipelineNumber_Call) Return(_a0 *model.Pipeline, _a1 error) *MockStore_GetPipelineNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetPipelineNumber_Call) RunAndReturn(run func(*model.Repo, int64) (*model.Pipeline, error)) *MockStore_GetPipelineNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetPipelineQueue provides a mock function with no fields
func (_m *MockStore) GetPipelineQueue() ([]*model.Feed, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPipelineQueue is a helper method to define mock.On call
func (_e *MockStore_Expecter) GetPipelineQueue() *MockStore_GetPipelineQueue_Call {
	return &MockStore_GetPipelineQueue_Call{Call: _e.mock.On("GetPipelineQueue")}
}

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

func (_c *MockStore_GetPipelineQueue_Call) Return(_a0 []*model.Feed, _a1 error) *MockStore_GetPipelineQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetRepo provides a mock function with given fields: _a0
func (_m *MockStore) GetRepo(_a0 int64) (*model.Repo, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Repo, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Repo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepo is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) GetRepo(_a0 interface{}) *MockStore_GetRepo_Call {
	return &MockStore_GetRepo_Call{Call: _e.mock.On("GetRepo", _a0)}
}

func (_c *MockStore_GetRepo_Call) Run(run func(_a0 int64)) *MockStore_GetRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_GetRepo_Call) Return(_a0 *model.Repo, _a1 error) *MockStore_GetRepo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetRepo_Call) RunAndReturn(run func(int64) (*model.Repo, error)) *MockStore_GetRepo_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepoCount provides a mock function with no fields
func (_m *MockStore) GetRepoCount() (int64, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepoCount is a helper method to define mock.On call
func (_e *MockStore_Expecter) GetRepoCount() *MockStore_GetRepoCount_Call {
	return &MockStore_GetRepoCount_Call{Call: _e.mock.On("GetRepoCount")}
}

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

func (_c *MockStore_GetRepoCount_Call) Return(_a0 int64, _a1 error) *MockStore_GetRepoCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetRepoForgeID provides a mock function with given fields: _a0
func (_m *MockStore) GetRepoForgeID(_a0 model.ForgeRemoteID) (*model.Repo, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID) (*model.Repo, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID) *model.Repo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(model.ForgeRemoteID) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepoForgeID is a helper method to define mock.On call
//   - _a0 model.ForgeRemoteID
func (_e *MockStore_Expecter) GetRepoForgeID(_a0 interface{}) *MockStore_GetRepoForgeID_Call {
	return &MockStore_GetRepoForgeID_Call{Call: _e.mock.On("GetRepoForgeID", _a0)}
}

func (_c *MockStore_GetRepoForgeID_Call) Run(run func(_a0 model.ForgeRemoteID)) *MockStore_GetRepoForgeID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.ForgeRemoteID))
	})
	return _c
}

func (_c *MockStore_GetRepoForgeID_Call) Return(_a0 *model.Repo, _a1 error) *MockStore_GetRepoForgeID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetRepoForgeID_Call) RunAndReturn(run func(model.ForgeRemoteID) (*model.Repo, error)) *MockStore_GetRepoForgeID_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepoLatestPipelines provides a mock function with given fields: _a0
func (_m *MockStore) GetRepoLatestPipelines(_a0 []int64) ([]*model.Pipeline, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Pipeline
	var r1 error
	if rf, ok := ret.Get(0).(func([]int64) ([]*model.Pipeline, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func([]int64) []*model.Pipeline); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Pipeline)
		}
	}

	if rf, ok := ret.Get(1).(func([]int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepoLatestPipelines is a helper method to define mock.On call
//   - _a0 []int64
func (_e *MockStore_Expecter) GetRepoLatestPipelines(_a0 interface{}) *MockStore_GetRepoLatestPipelines_Call {
	return &MockStore_GetRepoLatestPipelines_Call{Call: _e.mock.On("GetRepoLatestPipelines", _a0)}
}

func (_c *MockStore_GetRepoLatestPipelines_Call) Run(run func(_a0 []int64)) *MockStore_GetRepoLatestPipelines_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]int64))
	})
	return _c
}

func (_c *MockStore_GetRepoLatestPipelines_Call) Return(_a0 []*model.Pipeline, _a1 error) *MockStore_GetRepoLatestPipelines_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetRepoLatestPipelines_Call) RunAndReturn(run func([]int64) ([]*model.Pipeline, error)) *MockStore_GetRepoLatestPipelines_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepoName provides a mock function with given fields: _a0
func (_m *MockStore) GetRepoName(_a0 string) (*model.Repo, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*model.Repo, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(string) *model.Repo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepoName is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) GetRepoName(_a0 interface{}) *MockStore_GetRepoName_Call {
	return &MockStore_GetRepoName_Call{Call: _e.mock.On("GetRepoName", _a0)}
}

func (_c *MockStore_GetRepoName_Call) Run(run func(_a0 string)) *MockStore_GetRepoName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_GetRepoName_Call) Return(_a0 *model.Repo, _a1 error) *MockStore_GetRepoName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetRepoNameFallback provides a mock function with given fields: remoteID, fullName
func (_m *MockStore) GetRepoNameFallback(remoteID model.ForgeRemoteID, fullName string) (*model.Repo, error) {
	ret := _m.Called(remoteID, fullName)

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

	var r0 *model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) (*model.Repo, error)); ok {
		return rf(remoteID, fullName)
	}
	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) *model.Repo); ok {
		r0 = rf(remoteID, fullName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(model.ForgeRemoteID, string) error); ok {
		r1 = rf(remoteID, fullName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepoNameFallback is a helper method to define mock.On call
//   - remoteID model.ForgeRemoteID
//   - fullName string
func (_e *MockStore_Expecter) GetRepoNameFallback(remoteID interface{}, fullName interface{}) *MockStore_GetRepoNameFallback_Call {
	return &MockStore_GetRepoNameFallback_Call{Call: _e.mock.On("GetRepoNameFallback", remoteID, fullName)}
}

func (_c *MockStore_GetRepoNameFallback_Call) Run(run func(remoteID model.ForgeRemoteID, fullName string)) *MockStore_GetRepoNameFallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.ForgeRemoteID), args[1].(string))
	})
	return _c
}

func (_c *MockStore_GetRepoNameFallback_Call) Return(_a0 *model.Repo, _a1 error) *MockStore_GetRepoNameFallback_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetRepoNameFallback_Call) RunAndReturn(run func(model.ForgeRemoteID, string) (*model.Repo, error)) *MockStore_GetRepoNameFallback_Call {
	_c.Call.Return(run)
	return _c
}

// GetUser provides a mock function with given fields: _a0
func (_m *MockStore) GetUser(_a0 int64) (*model.User, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.User
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.User, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.User); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.User)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUser is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) GetUser(_a0 interface{}) *MockStore_GetUser_Call {
	return &MockStore_GetUser_Call{Call: _e.mock.On("GetUser", _a0)}
}

func (_c *MockStore_GetUser_Call) Run(run func(_a0 int64)) *MockStore_GetUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_GetUser_Call) Return(_a0 *model.User, _a1 error) *MockStore_GetUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetUser_Call) RunAndReturn(run func(int64) (*model.User, error)) *MockStore_GetUser_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserCount provides a mock function with no fields
func (_m *MockStore) GetUserCount() (int64, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUserCount is a helper method to define mock.On call
func (_e *MockStore_Expecter) GetUserCount() *MockStore_GetUserCount_Call {
	return &MockStore_GetUserCount_Call{Call: _e.mock.On("GetUserCount")}
}

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

func (_c *MockStore_GetUserCount_Call) Return(_a0 int64, _a1 error) *MockStore_GetUserCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetUserList provides a mock function with given fields: p
func (_m *MockStore) GetUserList(p *model.ListOptions) ([]*model.User, error) {
	ret := _m.Called(p)

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

	var r0 []*model.User
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.User, error)); ok {
		return rf(p)
	}
	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.User); ok {
		r0 = rf(p)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.User)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = rf(p)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUserList is a helper method to define mock.On call
//   - p *model.ListOptions
func (_e *MockStore_Expecter) GetUserList(p interface{}) *MockStore_GetUserList_Call {
	return &MockStore_GetUserList_Call{Call: _e.mock.On("GetUserList", p)}
}

func (_c *MockStore_GetUserList_Call) Run(run func(p *model.ListOptions)) *MockStore_GetUserList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_GetUserList_Call) Return(_a0 []*model.User, _a1 error) *MockStore_GetUserList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetUserList_Call) RunAndReturn(run func(*model.ListOptions) ([]*model.User, error)) *MockStore_GetUserList_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserLogin provides a mock function with given fields: _a0
func (_m *MockStore) GetUserLogin(_a0 string) (*model.User, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.User
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*model.User, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.User)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUserLogin is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) GetUserLogin(_a0 interface{}) *MockStore_GetUserLogin_Call {
	return &MockStore_GetUserLogin_Call{Call: _e.mock.On("GetUserLogin", _a0)}
}

func (_c *MockStore_GetUserLogin_Call) Run(run func(_a0 string)) *MockStore_GetUserLogin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_GetUserLogin_Call) Return(_a0 *model.User, _a1 error) *MockStore_GetUserLogin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetUserRemoteID provides a mock function with given fields: _a0, _a1
func (_m *MockStore) GetUserRemoteID(_a0 model.ForgeRemoteID, _a1 string) (*model.User, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.User
	var r1 error
	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) (*model.User, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) *model.User); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.User)
		}
	}

	if rf, ok := ret.Get(1).(func(model.ForgeRemoteID, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUserRemoteID is a helper method to define mock.On call
//   - _a0 model.ForgeRemoteID
//   - _a1 string
func (_e *MockStore_Expecter) GetUserRemoteID(_a0 interface{}, _a1 interface{}) *MockStore_GetUserRemoteID_Call {
	return &MockStore_GetUserRemoteID_Call{Call: _e.mock.On("GetUserRemoteID", _a0, _a1)}
}

func (_c *MockStore_GetUserRemoteID_Call) Run(run func(_a0 model.ForgeRemoteID, _a1 string)) *MockStore_GetUserRemoteID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.ForgeRemoteID), args[1].(string))
	})
	return _c
}

func (_c *MockStore_GetUserRemoteID_Call) Return(_a0 *model.User, _a1 error) *MockStore_GetUserRemoteID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GetUserRemoteID_Call) RunAndReturn(run func(model.ForgeRemoteID, string) (*model.User, error)) *MockStore_GetUserRemoteID_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalRegistryFind provides a mock function with given fields: _a0
func (_m *MockStore) GlobalRegistryFind(_a0 string) (*model.Registry, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*model.Registry, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(string) *model.Registry); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GlobalRegistryFind is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) GlobalRegistryFind(_a0 interface{}) *MockStore_GlobalRegistryFind_Call {
	return &MockStore_GlobalRegistryFind_Call{Call: _e.mock.On("GlobalRegistryFind", _a0)}
}

func (_c *MockStore_GlobalRegistryFind_Call) Run(run func(_a0 string)) *MockStore_GlobalRegistryFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_GlobalRegistryFind_Call) Return(_a0 *model.Registry, _a1 error) *MockStore_GlobalRegistryFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GlobalRegistryList provides a mock function with given fields: _a0
func (_m *MockStore) GlobalRegistryList(_a0 *model.ListOptions) ([]*model.Registry, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Registry, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Registry); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GlobalRegistryList is a helper method to define mock.On call
//   - _a0 *model.ListOptions
func (_e *MockStore_Expecter) GlobalRegistryList(_a0 interface{}) *MockStore_GlobalRegistryList_Call {
	return &MockStore_GlobalRegistryList_Call{Call: _e.mock.On("GlobalRegistryList", _a0)}
}

func (_c *MockStore_GlobalRegistryList_Call) Run(run func(_a0 *model.ListOptions)) *MockStore_GlobalRegistryList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_GlobalRegistryList_Call) Return(_a0 []*model.Registry, _a1 error) *MockStore_GlobalRegistryList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_GlobalRegistryList_Call) RunAndReturn(run func(*model.ListOptions) ([]*model.Registry, error)) *MockStore_GlobalRegistryList_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalSecretFind provides a mock function with given fields: _a0
func (_m *MockStore) GlobalSecretFind(_a0 string) (*model.Secret, error) {
	ret := _m.Called(_a0)

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

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

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

func (_c *MockStore_GlobalSecretFind_Call) Run(run func(_a0 string)) *MockStore_GlobalSecretFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_GlobalSecretFind_Call) Return(_a0 *model.Secret, _a1 error) *MockStore_GlobalSecretFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GlobalSecretList provides a mock function with given fields: _a0
func (_m *MockStore) GlobalSecretList(_a0 *model.ListOptions) ([]*model.Secret, error) {
	ret := _m.Called(_a0)

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

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

	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

func (_c *MockStore_GlobalSecretList_Call) Run(run func(_a0 *model.ListOptions)) *MockStore_GlobalSecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_GlobalSecretList_Call) Return(_a0 []*model.Secret, _a1 error) *MockStore_GlobalSecretList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// HasRedirectionForRepo provides a mock function with given fields: _a0, _a1
func (_m *MockStore) HasRedirectionForRepo(_a0 int64, _a1 string) (bool, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, string) (bool, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(int64, string) bool); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HasRedirectionForRepo is a helper method to define mock.On call
//   - _a0 int64
//   - _a1 string
func (_e *MockStore_Expecter) HasRedirectionForRepo(_a0 interface{}, _a1 interface{}) *MockStore_HasRedirectionForRepo_Call {
	return &MockStore_HasRedirectionForRepo_Call{Call: _e.mock.On("HasRedirectionForRepo", _a0, _a1)}
}

func (_c *MockStore_HasRedirectionForRepo_Call) Run(run func(_a0 int64, _a1 string)) *MockStore_HasRedirectionForRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(string))
	})
	return _c
}

func (_c *MockStore_HasRedirectionForRepo_Call) Return(_a0 bool, _a1 error) *MockStore_HasRedirectionForRepo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// LogAppend provides a mock function with given fields: _a0, _a1
func (_m *MockStore) LogAppend(_a0 *model.Step, _a1 []*model.LogEntry) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Step, []*model.LogEntry) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogAppend is a helper method to define mock.On call
//   - _a0 *model.Step
//   - _a1 []*model.LogEntry
func (_e *MockStore_Expecter) LogAppend(_a0 interface{}, _a1 interface{}) *MockStore_LogAppend_Call {
	return &MockStore_LogAppend_Call{Call: _e.mock.On("LogAppend", _a0, _a1)}
}

func (_c *MockStore_LogAppend_Call) Run(run func(_a0 *model.Step, _a1 []*model.LogEntry)) *MockStore_LogAppend_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Step), args[1].([]*model.LogEntry))
	})
	return _c
}

func (_c *MockStore_LogAppend_Call) Return(_a0 error) *MockStore_LogAppend_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_LogAppend_Call) RunAndReturn(run func(*model.Step, []*model.LogEntry) error) *MockStore_LogAppend_Call {
	_c.Call.Return(run)
	return _c
}

// LogDelete provides a mock function with given fields: _a0
func (_m *MockStore) LogDelete(_a0 *model.Step) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Step) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogDelete is a helper method to define mock.On call
//   - _a0 *model.Step
func (_e *MockStore_Expecter) LogDelete(_a0 interface{}) *MockStore_LogDelete_Call {
	return &MockStore_LogDelete_Call{Call: _e.mock.On("LogDelete", _a0)}
}

func (_c *MockStore_LogDelete_Call) Run(run func(_a0 *model.Step)) *MockStore_LogDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Step))
	})
	return _c
}

func (_c *MockStore_LogDelete_Call) Return(_a0 error) *MockStore_LogDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_LogDelete_Call) RunAndReturn(run func(*model.Step) error) *MockStore_LogDelete_Call {
	_c.Call.Return(run)
	return _c
}

// LogFind provides a mock function with given fields: _a0
func (_m *MockStore) LogFind(_a0 *model.Step) ([]*model.LogEntry, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.LogEntry
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Step) ([]*model.LogEntry, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.Step) []*model.LogEntry); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.LogEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Step) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LogFind is a helper method to define mock.On call
//   - _a0 *model.Step
func (_e *MockStore_Expecter) LogFind(_a0 interface{}) *MockStore_LogFind_Call {
	return &MockStore_LogFind_Call{Call: _e.mock.On("LogFind", _a0)}
}

func (_c *MockStore_LogFind_Call) Run(run func(_a0 *model.Step)) *MockStore_LogFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Step))
	})
	return _c
}

func (_c *MockStore_LogFind_Call) Return(_a0 []*model.LogEntry, _a1 error) *MockStore_LogFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_LogFind_Call) RunAndReturn(run func(*model.Step) ([]*model.LogEntry, error)) *MockStore_LogFind_Call {
	_c.Call.Return(run)
	return _c
}

// Migrate provides a mock function with given fields: _a0, _a1
func (_m *MockStore) Migrate(_a0 context.Context, _a1 bool) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Migrate is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 bool
func (_e *MockStore_Expecter) Migrate(_a0 interface{}, _a1 interface{}) *MockStore_Migrate_Call {
	return &MockStore_Migrate_Call{Call: _e.mock.On("Migrate", _a0, _a1)}
}

func (_c *MockStore_Migrate_Call) Run(run func(_a0 context.Context, _a1 bool)) *MockStore_Migrate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(bool))
	})
	return _c
}

func (_c *MockStore_Migrate_Call) Return(_a0 error) *MockStore_Migrate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_Migrate_Call) RunAndReturn(run func(context.Context, bool) error) *MockStore_Migrate_Call {
	_c.Call.Return(run)
	return _c
}

// OrgCreate provides a mock function with given fields: _a0
func (_m *MockStore) OrgCreate(_a0 *model.Org) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Org) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// OrgCreate is a helper method to define mock.On call
//   - _a0 *model.Org
func (_e *MockStore_Expecter) OrgCreate(_a0 interface{}) *MockStore_OrgCreate_Call {
	return &MockStore_OrgCreate_Call{Call: _e.mock.On("OrgCreate", _a0)}
}

func (_c *MockStore_OrgCreate_Call) Run(run func(_a0 *model.Org)) *MockStore_OrgCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Org))
	})
	return _c
}

func (_c *MockStore_OrgCreate_Call) Return(_a0 error) *MockStore_OrgCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_OrgCreate_Call) RunAndReturn(run func(*model.Org) error) *MockStore_OrgCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrgDelete provides a mock function with given fields: _a0
func (_m *MockStore) OrgDelete(_a0 int64) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// OrgDelete is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) OrgDelete(_a0 interface{}) *MockStore_OrgDelete_Call {
	return &MockStore_OrgDelete_Call{Call: _e.mock.On("OrgDelete", _a0)}
}

func (_c *MockStore_OrgDelete_Call) Run(run func(_a0 int64)) *MockStore_OrgDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_OrgDelete_Call) Return(_a0 error) *MockStore_OrgDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// OrgFindByName provides a mock function with given fields: _a0, _a1
func (_m *MockStore) OrgFindByName(_a0 string, _a1 int64) (*model.Org, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Org
	var r1 error
	if rf, ok := ret.Get(0).(func(string, int64) (*model.Org, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(string, int64) *model.Org); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Org)
		}
	}

	if rf, ok := ret.Get(1).(func(string, int64) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgFindByName is a helper method to define mock.On call
//   - _a0 string
//   - _a1 int64
func (_e *MockStore_Expecter) OrgFindByName(_a0 interface{}, _a1 interface{}) *MockStore_OrgFindByName_Call {
	return &MockStore_OrgFindByName_Call{Call: _e.mock.On("OrgFindByName", _a0, _a1)}
}

func (_c *MockStore_OrgFindByName_Call) Run(run func(_a0 string, _a1 int64)) *MockStore_OrgFindByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(int64))
	})
	return _c
}

func (_c *MockStore_OrgFindByName_Call) Return(_a0 *model.Org, _a1 error) *MockStore_OrgFindByName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_OrgFindByName_Call) RunAndReturn(run func(string, int64) (*model.Org, error)) *MockStore_OrgFindByName_Call {
	_c.Call.Return(run)
	return _c
}

// OrgGet provides a mock function with given fields: _a0
func (_m *MockStore) OrgGet(_a0 int64) (*model.Org, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Org
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Org, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Org); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Org)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgGet is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) OrgGet(_a0 interface{}) *MockStore_OrgGet_Call {
	return &MockStore_OrgGet_Call{Call: _e.mock.On("OrgGet", _a0)}
}

func (_c *MockStore_OrgGet_Call) Run(run func(_a0 int64)) *MockStore_OrgGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_OrgGet_Call) Return(_a0 *model.Org, _a1 error) *MockStore_OrgGet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_OrgGet_Call) RunAndReturn(run func(int64) (*model.Org, error)) *MockStore_OrgGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrgList provides a mock function with given fields: _a0
func (_m *MockStore) OrgList(_a0 *model.ListOptions) ([]*model.Org, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Org
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Org, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Org); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Org)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgList is a helper method to define mock.On call
//   - _a0 *model.ListOptions
func (_e *MockStore_Expecter) OrgList(_a0 interface{}) *MockStore_OrgList_Call {
	return &MockStore_OrgList_Call{Call: _e.mock.On("OrgList", _a0)}
}

func (_c *MockStore_OrgList_Call) Run(run func(_a0 *model.ListOptions)) *MockStore_OrgList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_OrgList_Call) Return(_a0 []*model.Org, _a1 error) *MockStore_OrgList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_OrgList_Call) RunAndReturn(run func(*model.ListOptions) ([]*model.Org, error)) *MockStore_OrgList_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistryFind provides a mock function with given fields: _a0, _a1
func (_m *MockStore) OrgRegistryFind(_a0 int64, _a1 string) (*model.Registry, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, string) (*model.Registry, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(int64, string) *model.Registry); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgRegistryFind is a helper method to define mock.On call
//   - _a0 int64
//   - _a1 string
func (_e *MockStore_Expecter) OrgRegistryFind(_a0 interface{}, _a1 interface{}) *MockStore_OrgRegistryFind_Call {
	return &MockStore_OrgRegistryFind_Call{Call: _e.mock.On("OrgRegistryFind", _a0, _a1)}
}

func (_c *MockStore_OrgRegistryFind_Call) Run(run func(_a0 int64, _a1 string)) *MockStore_OrgRegistryFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(string))
	})
	return _c
}

func (_c *MockStore_OrgRegistryFind_Call) Return(_a0 *model.Registry, _a1 error) *MockStore_OrgRegistryFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_OrgRegistryFind_Call) RunAndReturn(run func(int64, string) (*model.Registry, error)) *MockStore_OrgRegistryFind_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRegistryList provides a mock function with given fields: _a0, _a1
func (_m *MockStore) OrgRegistryList(_a0 int64, _a1 *model.ListOptions) ([]*model.Registry, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 []*model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Registry, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Registry); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgRegistryList is a helper method to define mock.On call
//   - _a0 int64
//   - _a1 *model.ListOptions
func (_e *MockStore_Expecter) OrgRegistryList(_a0 interface{}, _a1 interface{}) *MockStore_OrgRegistryList_Call {
	return &MockStore_OrgRegistryList_Call{Call: _e.mock.On("OrgRegistryList", _a0, _a1)}
}

func (_c *MockStore_OrgRegistryList_Call) Run(run func(_a0 int64, _a1 *model.ListOptions)) *MockStore_OrgRegistryList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_OrgRegistryList_Call) Return(_a0 []*model.Registry, _a1 error) *MockStore_OrgRegistryList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_OrgRegistryList_Call) RunAndReturn(run func(int64, *model.ListOptions) ([]*model.Registry, error)) *MockStore_OrgRegistryList_Call {
	_c.Call.Return(run)
	return _c
}

// OrgRepoList provides a mock function with given fields: _a0, _a1
func (_m *MockStore) OrgRepoList(_a0 *model.Org, _a1 *model.ListOptions) ([]*model.Repo, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 []*model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Org, *model.ListOptions) ([]*model.Repo, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Org, *model.ListOptions) []*model.Repo); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Org, *model.ListOptions) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgRepoList is a helper method to define mock.On call
//   - _a0 *model.Org
//   - _a1 *model.ListOptions
func (_e *MockStore_Expecter) OrgRepoList(_a0 interface{}, _a1 interface{}) *MockStore_OrgRepoList_Call {
	return &MockStore_OrgRepoList_Call{Call: _e.mock.On("OrgRepoList", _a0, _a1)}
}

func (_c *MockStore_OrgRepoList_Call) Run(run func(_a0 *model.Org, _a1 *model.ListOptions)) *MockStore_OrgRepoList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Org), args[1].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_OrgRepoList_Call) Return(_a0 []*model.Repo, _a1 error) *MockStore_OrgRepoList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_OrgRepoList_Call) RunAndReturn(run func(*model.Org, *model.ListOptions) ([]*model.Repo, error)) *MockStore_OrgRepoList_Call {
	_c.Call.Return(run)
	return _c
}

// OrgSecretFind provides a mock function with given fields: _a0, _a1
func (_m *MockStore) OrgSecretFind(_a0 int64, _a1 string) (*model.Secret, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Secret
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, string) (*model.Secret, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(int64, string) *model.Secret); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Secret)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgSecretFind is a helper method to define mock.On call
//   - _a0 int64
//   - _a1 string
func (_e *MockStore_Expecter) OrgSecretFind(_a0 interface{}, _a1 interface{}) *MockStore_OrgSecretFind_Call {
	return &MockStore_OrgSecretFind_Call{Call: _e.mock.On("OrgSecretFind", _a0, _a1)}
}

func (_c *MockStore_OrgSecretFind_Call) Run(run func(_a0 int64, _a1 string)) *MockStore_OrgSecretFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(string))
	})
	return _c
}

func (_c *MockStore_OrgSecretFind_Call) Return(_a0 *model.Secret, _a1 error) *MockStore_OrgSecretFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// OrgSecretList provides a mock function with given fields: _a0, _a1
func (_m *MockStore) OrgSecretList(_a0 int64, _a1 *model.ListOptions) ([]*model.Secret, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 []*model.Secret
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Secret, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Secret); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Secret)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OrgSecretList is a helper method to define mock.On call
//   - _a0 int64
//   - _a1 *model.ListOptions
func (_e *MockStore_Expecter) OrgSecretList(_a0 interface{}, _a1 interface{}) *MockStore_OrgSecretList_Call {
	return &MockStore_OrgSecretList_Call{Call: _e.mock.On("OrgSecretList", _a0, _a1)}
}

func (_c *MockStore_OrgSecretList_Call) Run(run func(_a0 int64, _a1 *model.ListOptions)) *MockStore_OrgSecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_OrgSecretList_Call) Return(_a0 []*model.Secret, _a1 error) *MockStore_OrgSecretList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// OrgUpdate provides a mock function with given fields: _a0
func (_m *MockStore) OrgUpdate(_a0 *model.Org) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Org) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// OrgUpdate is a helper method to define mock.On call
//   - _a0 *model.Org
func (_e *MockStore_Expecter) OrgUpdate(_a0 interface{}) *MockStore_OrgUpdate_Call {
	return &MockStore_OrgUpdate_Call{Call: _e.mock.On("OrgUpdate", _a0)}
}

func (_c *MockStore_OrgUpdate_Call) Run(run func(_a0 *model.Org)) *MockStore_OrgUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Org))
	})
	return _c
}

func (_c *MockStore_OrgUpdate_Call) Return(_a0 error) *MockStore_OrgUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_OrgUpdate_Call) RunAndReturn(run func(*model.Org) error) *MockStore_OrgUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// PermFind provides a mock function with given fields: user, repo
func (_m *MockStore) PermFind(user *model.User, repo *model.Repo) (*model.Perm, error) {
	ret := _m.Called(user, repo)

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

	var r0 *model.Perm
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) (*model.Perm, error)); ok {
		return rf(user, repo)
	}
	if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) *model.Perm); ok {
		r0 = rf(user, repo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Perm)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.User, *model.Repo) error); ok {
		r1 = rf(user, repo)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// PermFind is a helper method to define mock.On call
//   - user *model.User
//   - repo *model.Repo
func (_e *MockStore_Expecter) PermFind(user interface{}, repo interface{}) *MockStore_PermFind_Call {
	return &MockStore_PermFind_Call{Call: _e.mock.On("PermFind", user, repo)}
}

func (_c *MockStore_PermFind_Call) Run(run func(user *model.User, repo *model.Repo)) *MockStore_PermFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User), args[1].(*model.Repo))
	})
	return _c
}

func (_c *MockStore_PermFind_Call) Return(_a0 *model.Perm, _a1 error) *MockStore_PermFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_PermFind_Call) RunAndReturn(run func(*model.User, *model.Repo) (*model.Perm, error)) *MockStore_PermFind_Call {
	_c.Call.Return(run)
	return _c
}

// PermUpsert provides a mock function with given fields: perm
func (_m *MockStore) PermUpsert(perm *model.Perm) error {
	ret := _m.Called(perm)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Perm) error); ok {
		r0 = rf(perm)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PermUpsert is a helper method to define mock.On call
//   - perm *model.Perm
func (_e *MockStore_Expecter) PermUpsert(perm interface{}) *MockStore_PermUpsert_Call {
	return &MockStore_PermUpsert_Call{Call: _e.mock.On("PermUpsert", perm)}
}

func (_c *MockStore_PermUpsert_Call) Run(run func(perm *model.Perm)) *MockStore_PermUpsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Perm))
	})
	return _c
}

func (_c *MockStore_PermUpsert_Call) Return(_a0 error) *MockStore_PermUpsert_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_PermUpsert_Call) RunAndReturn(run func(*model.Perm) error) *MockStore_PermUpsert_Call {
	_c.Call.Return(run)
	return _c
}

// Ping provides a mock function with no fields
func (_m *MockStore) Ping() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Ping is a helper method to define mock.On call
func (_e *MockStore_Expecter) Ping() *MockStore_Ping_Call {
	return &MockStore_Ping_Call{Call: _e.mock.On("Ping")}
}

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

func (_c *MockStore_Ping_Call) Return(_a0 error) *MockStore_Ping_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_Ping_Call) RunAndReturn(run func() error) *MockStore_Ping_Call {
	_c.Call.Return(run)
	return _c
}

// PipelineConfigCreate provides a mock function with given fields: _a0
func (_m *MockStore) PipelineConfigCreate(_a0 *model.PipelineConfig) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.PipelineConfig) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PipelineConfigCreate is a helper method to define mock.On call
//   - _a0 *model.PipelineConfig
func (_e *MockStore_Expecter) PipelineConfigCreate(_a0 interface{}) *MockStore_PipelineConfigCreate_Call {
	return &MockStore_PipelineConfigCreate_Call{Call: _e.mock.On("PipelineConfigCreate", _a0)}
}

func (_c *MockStore_PipelineConfigCreate_Call) Run(run func(_a0 *model.PipelineConfig)) *MockStore_PipelineConfigCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.PipelineConfig))
	})
	return _c
}

func (_c *MockStore_PipelineConfigCreate_Call) Return(_a0 error) *MockStore_PipelineConfigCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_PipelineConfigCreate_Call) RunAndReturn(run func(*model.PipelineConfig) error) *MockStore_PipelineConfigCreate_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryCreate provides a mock function with given fields: _a0
func (_m *MockStore) RegistryCreate(_a0 *model.Registry) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegistryCreate is a helper method to define mock.On call
//   - _a0 *model.Registry
func (_e *MockStore_Expecter) RegistryCreate(_a0 interface{}) *MockStore_RegistryCreate_Call {
	return &MockStore_RegistryCreate_Call{Call: _e.mock.On("RegistryCreate", _a0)}
}

func (_c *MockStore_RegistryCreate_Call) Run(run func(_a0 *model.Registry)) *MockStore_RegistryCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Registry))
	})
	return _c
}

func (_c *MockStore_RegistryCreate_Call) Return(_a0 error) *MockStore_RegistryCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_RegistryCreate_Call) RunAndReturn(run func(*model.Registry) error) *MockStore_RegistryCreate_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryDelete provides a mock function with given fields: _a0
func (_m *MockStore) RegistryDelete(_a0 *model.Registry) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegistryDelete is a helper method to define mock.On call
//   - _a0 *model.Registry
func (_e *MockStore_Expecter) RegistryDelete(_a0 interface{}) *MockStore_RegistryDelete_Call {
	return &MockStore_RegistryDelete_Call{Call: _e.mock.On("RegistryDelete", _a0)}
}

func (_c *MockStore_RegistryDelete_Call) Run(run func(_a0 *model.Registry)) *MockStore_RegistryDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Registry))
	})
	return _c
}

func (_c *MockStore_RegistryDelete_Call) Return(_a0 error) *MockStore_RegistryDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_RegistryDelete_Call) RunAndReturn(run func(*model.Registry) error) *MockStore_RegistryDelete_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryFind provides a mock function with given fields: _a0, _a1
func (_m *MockStore) RegistryFind(_a0 *model.Repo, _a1 string) (*model.Registry, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Registry, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Registry); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RegistryFind is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 string
func (_e *MockStore_Expecter) RegistryFind(_a0 interface{}, _a1 interface{}) *MockStore_RegistryFind_Call {
	return &MockStore_RegistryFind_Call{Call: _e.mock.On("RegistryFind", _a0, _a1)}
}

func (_c *MockStore_RegistryFind_Call) Run(run func(_a0 *model.Repo, _a1 string)) *MockStore_RegistryFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(string))
	})
	return _c
}

func (_c *MockStore_RegistryFind_Call) Return(_a0 *model.Registry, _a1 error) *MockStore_RegistryFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_RegistryFind_Call) RunAndReturn(run func(*model.Repo, string) (*model.Registry, error)) *MockStore_RegistryFind_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryList provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockStore) RegistryList(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions) ([]*model.Registry, error) {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 []*model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) ([]*model.Registry, error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) []*model.Registry); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, bool, *model.ListOptions) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RegistryList is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 bool
//   - _a2 *model.ListOptions
func (_e *MockStore_Expecter) RegistryList(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockStore_RegistryList_Call {
	return &MockStore_RegistryList_Call{Call: _e.mock.On("RegistryList", _a0, _a1, _a2)}
}

func (_c *MockStore_RegistryList_Call) Run(run func(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions)) *MockStore_RegistryList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(bool), args[2].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_RegistryList_Call) Return(_a0 []*model.Registry, _a1 error) *MockStore_RegistryList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_RegistryList_Call) RunAndReturn(run func(*model.Repo, bool, *model.ListOptions) ([]*model.Registry, error)) *MockStore_RegistryList_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryListAll provides a mock function with no fields
func (_m *MockStore) RegistryListAll() ([]*model.Registry, error) {
	ret := _m.Called()

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

	var r0 []*model.Registry
	var r1 error
	if rf, ok := ret.Get(0).(func() ([]*model.Registry, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() []*model.Registry); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Registry)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RegistryListAll is a helper method to define mock.On call
func (_e *MockStore_Expecter) RegistryListAll() *MockStore_RegistryListAll_Call {
	return &MockStore_RegistryListAll_Call{Call: _e.mock.On("RegistryListAll")}
}

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

func (_c *MockStore_RegistryListAll_Call) Return(_a0 []*model.Registry, _a1 error) *MockStore_RegistryListAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_RegistryListAll_Call) RunAndReturn(run func() ([]*model.Registry, error)) *MockStore_RegistryListAll_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryUpdate provides a mock function with given fields: _a0
func (_m *MockStore) RegistryUpdate(_a0 *model.Registry) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegistryUpdate is a helper method to define mock.On call
//   - _a0 *model.Registry
func (_e *MockStore_Expecter) RegistryUpdate(_a0 interface{}) *MockStore_RegistryUpdate_Call {
	return &MockStore_RegistryUpdate_Call{Call: _e.mock.On("RegistryUpdate", _a0)}
}

func (_c *MockStore_RegistryUpdate_Call) Run(run func(_a0 *model.Registry)) *MockStore_RegistryUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Registry))
	})
	return _c
}

func (_c *MockStore_RegistryUpdate_Call) Return(_a0 error) *MockStore_RegistryUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_RegistryUpdate_Call) RunAndReturn(run func(*model.Registry) error) *MockStore_RegistryUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// RepoList provides a mock function with given fields: user, owned, active
func (_m *MockStore) RepoList(user *model.User, owned bool, active bool) ([]*model.Repo, error) {
	ret := _m.Called(user, owned, active)

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

	var r0 []*model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.User, bool, bool) ([]*model.Repo, error)); ok {
		return rf(user, owned, active)
	}
	if rf, ok := ret.Get(0).(func(*model.User, bool, bool) []*model.Repo); ok {
		r0 = rf(user, owned, active)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.User, bool, bool) error); ok {
		r1 = rf(user, owned, active)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RepoList is a helper method to define mock.On call
//   - user *model.User
//   - owned bool
//   - active bool
func (_e *MockStore_Expecter) RepoList(user interface{}, owned interface{}, active interface{}) *MockStore_RepoList_Call {
	return &MockStore_RepoList_Call{Call: _e.mock.On("RepoList", user, owned, active)}
}

func (_c *MockStore_RepoList_Call) Run(run func(user *model.User, owned bool, active bool)) *MockStore_RepoList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User), args[1].(bool), args[2].(bool))
	})
	return _c
}

func (_c *MockStore_RepoList_Call) Return(_a0 []*model.Repo, _a1 error) *MockStore_RepoList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_RepoList_Call) RunAndReturn(run func(*model.User, bool, bool) ([]*model.Repo, error)) *MockStore_RepoList_Call {
	_c.Call.Return(run)
	return _c
}

// RepoListAll provides a mock function with given fields: active, p
func (_m *MockStore) RepoListAll(active bool, p *model.ListOptions) ([]*model.Repo, error) {
	ret := _m.Called(active, p)

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

	var r0 []*model.Repo
	var r1 error
	if rf, ok := ret.Get(0).(func(bool, *model.ListOptions) ([]*model.Repo, error)); ok {
		return rf(active, p)
	}
	if rf, ok := ret.Get(0).(func(bool, *model.ListOptions) []*model.Repo); ok {
		r0 = rf(active, p)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Repo)
		}
	}

	if rf, ok := ret.Get(1).(func(bool, *model.ListOptions) error); ok {
		r1 = rf(active, p)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RepoListAll is a helper method to define mock.On call
//   - active bool
//   - p *model.ListOptions
func (_e *MockStore_Expecter) RepoListAll(active interface{}, p interface{}) *MockStore_RepoListAll_Call {
	return &MockStore_RepoListAll_Call{Call: _e.mock.On("RepoListAll", active, p)}
}

func (_c *MockStore_RepoListAll_Call) Run(run func(active bool, p *model.ListOptions)) *MockStore_RepoListAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool), args[1].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_RepoListAll_Call) Return(_a0 []*model.Repo, _a1 error) *MockStore_RepoListAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_RepoListAll_Call) RunAndReturn(run func(bool, *model.ListOptions) ([]*model.Repo, error)) *MockStore_RepoListAll_Call {
	_c.Call.Return(run)
	return _c
}

// RepoListLatest provides a mock function with given fields: _a0
func (_m *MockStore) RepoListLatest(_a0 *model.User) ([]*model.Feed, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Feed
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.User) ([]*model.Feed, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.User) []*model.Feed); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Feed)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.User) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RepoListLatest is a helper method to define mock.On call
//   - _a0 *model.User
func (_e *MockStore_Expecter) RepoListLatest(_a0 interface{}) *MockStore_RepoListLatest_Call {
	return &MockStore_RepoListLatest_Call{Call: _e.mock.On("RepoListLatest", _a0)}
}

func (_c *MockStore_RepoListLatest_Call) Run(run func(_a0 *model.User)) *MockStore_RepoListLatest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User))
	})
	return _c
}

func (_c *MockStore_RepoListLatest_Call) Return(_a0 []*model.Feed, _a1 error) *MockStore_RepoListLatest_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_RepoListLatest_Call) RunAndReturn(run func(*model.User) ([]*model.Feed, error)) *MockStore_RepoListLatest_Call {
	_c.Call.Return(run)
	return _c
}

// SecretCreate provides a mock function with given fields: _a0
func (_m *MockStore) SecretCreate(_a0 *model.Secret) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// SecretCreate is a helper method to define mock.On call
//   - _a0 *model.Secret
func (_e *MockStore_Expecter) SecretCreate(_a0 interface{}) *MockStore_SecretCreate_Call {
	return &MockStore_SecretCreate_Call{Call: _e.mock.On("SecretCreate", _a0)}
}

func (_c *MockStore_SecretCreate_Call) Run(run func(_a0 *model.Secret)) *MockStore_SecretCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Secret))
	})
	return _c
}

func (_c *MockStore_SecretCreate_Call) Return(_a0 error) *MockStore_SecretCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// SecretDelete provides a mock function with given fields: _a0
func (_m *MockStore) SecretDelete(_a0 *model.Secret) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// SecretDelete is a helper method to define mock.On call
//   - _a0 *model.Secret
func (_e *MockStore_Expecter) SecretDelete(_a0 interface{}) *MockStore_SecretDelete_Call {
	return &MockStore_SecretDelete_Call{Call: _e.mock.On("SecretDelete", _a0)}
}

func (_c *MockStore_SecretDelete_Call) Run(run func(_a0 *model.Secret)) *MockStore_SecretDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Secret))
	})
	return _c
}

func (_c *MockStore_SecretDelete_Call) Return(_a0 error) *MockStore_SecretDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// SecretFind provides a mock function with given fields: _a0, _a1
func (_m *MockStore) SecretFind(_a0 *model.Repo, _a1 string) (*model.Secret, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Secret
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Secret, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Secret); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Secret)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SecretFind is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 string
func (_e *MockStore_Expecter) SecretFind(_a0 interface{}, _a1 interface{}) *MockStore_SecretFind_Call {
	return &MockStore_SecretFind_Call{Call: _e.mock.On("SecretFind", _a0, _a1)}
}

func (_c *MockStore_SecretFind_Call) Run(run func(_a0 *model.Repo, _a1 string)) *MockStore_SecretFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(string))
	})
	return _c
}

func (_c *MockStore_SecretFind_Call) Return(_a0 *model.Secret, _a1 error) *MockStore_SecretFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// SecretList provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockStore) SecretList(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions) ([]*model.Secret, error) {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 []*model.Secret
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) ([]*model.Secret, error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) []*model.Secret); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Secret)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Repo, bool, *model.ListOptions) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SecretList is a helper method to define mock.On call
//   - _a0 *model.Repo
//   - _a1 bool
//   - _a2 *model.ListOptions
func (_e *MockStore_Expecter) SecretList(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockStore_SecretList_Call {
	return &MockStore_SecretList_Call{Call: _e.mock.On("SecretList", _a0, _a1, _a2)}
}

func (_c *MockStore_SecretList_Call) Run(run func(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions)) *MockStore_SecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo), args[1].(bool), args[2].(*model.ListOptions))
	})
	return _c
}

func (_c *MockStore_SecretList_Call) Return(_a0 []*model.Secret, _a1 error) *MockStore_SecretList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// SecretListAll provides a mock function with no fields
func (_m *MockStore) SecretListAll() ([]*model.Secret, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SecretListAll is a helper method to define mock.On call
func (_e *MockStore_Expecter) SecretListAll() *MockStore_SecretListAll_Call {
	return &MockStore_SecretListAll_Call{Call: _e.mock.On("SecretListAll")}
}

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

func (_c *MockStore_SecretListAll_Call) Return(_a0 []*model.Secret, _a1 error) *MockStore_SecretListAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// SecretUpdate provides a mock function with given fields: _a0
func (_m *MockStore) SecretUpdate(_a0 *model.Secret) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// SecretUpdate is a helper method to define mock.On call
//   - _a0 *model.Secret
func (_e *MockStore_Expecter) SecretUpdate(_a0 interface{}) *MockStore_SecretUpdate_Call {
	return &MockStore_SecretUpdate_Call{Call: _e.mock.On("SecretUpdate", _a0)}
}

func (_c *MockStore_SecretUpdate_Call) Run(run func(_a0 *model.Secret)) *MockStore_SecretUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Secret))
	})
	return _c
}

func (_c *MockStore_SecretUpdate_Call) Return(_a0 error) *MockStore_SecretUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ServerConfigDelete provides a mock function with given fields: _a0
func (_m *MockStore) ServerConfigDelete(_a0 string) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// ServerConfigDelete is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) ServerConfigDelete(_a0 interface{}) *MockStore_ServerConfigDelete_Call {
	return &MockStore_ServerConfigDelete_Call{Call: _e.mock.On("ServerConfigDelete", _a0)}
}

func (_c *MockStore_ServerConfigDelete_Call) Run(run func(_a0 string)) *MockStore_ServerConfigDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_ServerConfigDelete_Call) Return(_a0 error) *MockStore_ServerConfigDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ServerConfigGet provides a mock function with given fields: _a0
func (_m *MockStore) ServerConfigGet(_a0 string) (string, error) {
	ret := _m.Called(_a0)

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

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

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ServerConfigGet is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) ServerConfigGet(_a0 interface{}) *MockStore_ServerConfigGet_Call {
	return &MockStore_ServerConfigGet_Call{Call: _e.mock.On("ServerConfigGet", _a0)}
}

func (_c *MockStore_ServerConfigGet_Call) Run(run func(_a0 string)) *MockStore_ServerConfigGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_ServerConfigGet_Call) Return(_a0 string, _a1 error) *MockStore_ServerConfigGet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ServerConfigSet provides a mock function with given fields: _a0, _a1
func (_m *MockStore) ServerConfigSet(_a0 string, _a1 string) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ServerConfigSet is a helper method to define mock.On call
//   - _a0 string
//   - _a1 string
func (_e *MockStore_Expecter) ServerConfigSet(_a0 interface{}, _a1 interface{}) *MockStore_ServerConfigSet_Call {
	return &MockStore_ServerConfigSet_Call{Call: _e.mock.On("ServerConfigSet", _a0, _a1)}
}

func (_c *MockStore_ServerConfigSet_Call) Run(run func(_a0 string, _a1 string)) *MockStore_ServerConfigSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockStore_ServerConfigSet_Call) Return(_a0 error) *MockStore_ServerConfigSet_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// SetPipelineLogPurged provides a mock function with given fields: _a0
func (_m *MockStore) SetPipelineLogPurged(_a0 *model.Pipeline) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetPipelineLogPurged is a helper method to define mock.On call
//   - _a0 *model.Pipeline
func (_e *MockStore_Expecter) SetPipelineLogPurged(_a0 interface{}) *MockStore_SetPipelineLogPurged_Call {
	return &MockStore_SetPipelineLogPurged_Call{Call: _e.mock.On("SetPipelineLogPurged", _a0)}
}

func (_c *MockStore_SetPipelineLogPurged_Call) Run(run func(_a0 *model.Pipeline)) *MockStore_SetPipelineLogPurged_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline))
	})
	return _c
}

func (_c *MockStore_SetPipelineLogPurged_Call) Return(_a0 error) *MockStore_SetPipelineLogPurged_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_SetPipelineLogPurged_Call) RunAndReturn(run func(*model.Pipeline) error) *MockStore_SetPipelineLogPurged_Call {
	_c.Call.Return(run)
	return _c
}

// StepByUUID provides a mock function with given fields: _a0
func (_m *MockStore) StepByUUID(_a0 string) (*model.Step, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Step
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*model.Step, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(string) *model.Step); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Step)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StepByUUID is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) StepByUUID(_a0 interface{}) *MockStore_StepByUUID_Call {
	return &MockStore_StepByUUID_Call{Call: _e.mock.On("StepByUUID", _a0)}
}

func (_c *MockStore_StepByUUID_Call) Run(run func(_a0 string)) *MockStore_StepByUUID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_StepByUUID_Call) Return(_a0 *model.Step, _a1 error) *MockStore_StepByUUID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// StepChild provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockStore) StepChild(_a0 *model.Pipeline, _a1 int, _a2 string) (*model.Step, error) {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 *model.Step
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline, int, string) (*model.Step, error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(*model.Pipeline, int, string) *model.Step); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Step)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Pipeline, int, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StepChild is a helper method to define mock.On call
//   - _a0 *model.Pipeline
//   - _a1 int
//   - _a2 string
func (_e *MockStore_Expecter) StepChild(_a0 interface{}, _a1 interface{}, _a2 interface{}) *MockStore_StepChild_Call {
	return &MockStore_StepChild_Call{Call: _e.mock.On("StepChild", _a0, _a1, _a2)}
}

func (_c *MockStore_StepChild_Call) Run(run func(_a0 *model.Pipeline, _a1 int, _a2 string)) *MockStore_StepChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline), args[1].(int), args[2].(string))
	})
	return _c
}

func (_c *MockStore_StepChild_Call) Return(_a0 *model.Step, _a1 error) *MockStore_StepChild_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_StepChild_Call) RunAndReturn(run func(*model.Pipeline, int, string) (*model.Step, error)) *MockStore_StepChild_Call {
	_c.Call.Return(run)
	return _c
}

// StepFind provides a mock function with given fields: _a0, _a1
func (_m *MockStore) StepFind(_a0 *model.Pipeline, _a1 int) (*model.Step, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *model.Step
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline, int) (*model.Step, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(*model.Pipeline, int) *model.Step); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Step)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Pipeline, int) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StepFind is a helper method to define mock.On call
//   - _a0 *model.Pipeline
//   - _a1 int
func (_e *MockStore_Expecter) StepFind(_a0 interface{}, _a1 interface{}) *MockStore_StepFind_Call {
	return &MockStore_StepFind_Call{Call: _e.mock.On("StepFind", _a0, _a1)}
}

func (_c *MockStore_StepFind_Call) Run(run func(_a0 *model.Pipeline, _a1 int)) *MockStore_StepFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline), args[1].(int))
	})
	return _c
}

func (_c *MockStore_StepFind_Call) Return(_a0 *model.Step, _a1 error) *MockStore_StepFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_StepFind_Call) RunAndReturn(run func(*model.Pipeline, int) (*model.Step, error)) *MockStore_StepFind_Call {
	_c.Call.Return(run)
	return _c
}

// StepList provides a mock function with given fields: _a0
func (_m *MockStore) StepList(_a0 *model.Pipeline) ([]*model.Step, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Step
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline) ([]*model.Step, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.Pipeline) []*model.Step); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Step)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StepList is a helper method to define mock.On call
//   - _a0 *model.Pipeline
func (_e *MockStore_Expecter) StepList(_a0 interface{}) *MockStore_StepList_Call {
	return &MockStore_StepList_Call{Call: _e.mock.On("StepList", _a0)}
}

func (_c *MockStore_StepList_Call) Run(run func(_a0 *model.Pipeline)) *MockStore_StepList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline))
	})
	return _c
}

func (_c *MockStore_StepList_Call) Return(_a0 []*model.Step, _a1 error) *MockStore_StepList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_StepList_Call) RunAndReturn(run func(*model.Pipeline) ([]*model.Step, error)) *MockStore_StepList_Call {
	_c.Call.Return(run)
	return _c
}

// StepListFromWorkflowFind provides a mock function with given fields: _a0
func (_m *MockStore) StepListFromWorkflowFind(_a0 *model.Workflow) ([]*model.Step, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Step
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Workflow) ([]*model.Step, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.Workflow) []*model.Step); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Step)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Workflow) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StepListFromWorkflowFind is a helper method to define mock.On call
//   - _a0 *model.Workflow
func (_e *MockStore_Expecter) StepListFromWorkflowFind(_a0 interface{}) *MockStore_StepListFromWorkflowFind_Call {
	return &MockStore_StepListFromWorkflowFind_Call{Call: _e.mock.On("StepListFromWorkflowFind", _a0)}
}

func (_c *MockStore_StepListFromWorkflowFind_Call) Run(run func(_a0 *model.Workflow)) *MockStore_StepListFromWorkflowFind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Workflow))
	})
	return _c
}

func (_c *MockStore_StepListFromWorkflowFind_Call) Return(_a0 []*model.Step, _a1 error) *MockStore_StepListFromWorkflowFind_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_StepListFromWorkflowFind_Call) RunAndReturn(run func(*model.Workflow) ([]*model.Step, error)) *MockStore_StepListFromWorkflowFind_Call {
	_c.Call.Return(run)
	return _c
}

// StepLoad provides a mock function with given fields: _a0
func (_m *MockStore) StepLoad(_a0 int64) (*model.Step, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Step
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Step, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Step); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Step)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StepLoad is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) StepLoad(_a0 interface{}) *MockStore_StepLoad_Call {
	return &MockStore_StepLoad_Call{Call: _e.mock.On("StepLoad", _a0)}
}

func (_c *MockStore_StepLoad_Call) Run(run func(_a0 int64)) *MockStore_StepLoad_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_StepLoad_Call) Return(_a0 *model.Step, _a1 error) *MockStore_StepLoad_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_StepLoad_Call) RunAndReturn(run func(int64) (*model.Step, error)) *MockStore_StepLoad_Call {
	_c.Call.Return(run)
	return _c
}

// StepUpdate provides a mock function with given fields: _a0
func (_m *MockStore) StepUpdate(_a0 *model.Step) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Step) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// StepUpdate is a helper method to define mock.On call
//   - _a0 *model.Step
func (_e *MockStore_Expecter) StepUpdate(_a0 interface{}) *MockStore_StepUpdate_Call {
	return &MockStore_StepUpdate_Call{Call: _e.mock.On("StepUpdate", _a0)}
}

func (_c *MockStore_StepUpdate_Call) Run(run func(_a0 *model.Step)) *MockStore_StepUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Step))
	})
	return _c
}

func (_c *MockStore_StepUpdate_Call) Return(_a0 error) *MockStore_StepUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_StepUpdate_Call) RunAndReturn(run func(*model.Step) error) *MockStore_StepUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// TaskDelete provides a mock function with given fields: _a0
func (_m *MockStore) TaskDelete(_a0 string) error {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// TaskDelete is a helper method to define mock.On call
//   - _a0 string
func (_e *MockStore_Expecter) TaskDelete(_a0 interface{}) *MockStore_TaskDelete_Call {
	return &MockStore_TaskDelete_Call{Call: _e.mock.On("TaskDelete", _a0)}
}

func (_c *MockStore_TaskDelete_Call) Run(run func(_a0 string)) *MockStore_TaskDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockStore_TaskDelete_Call) Return(_a0 error) *MockStore_TaskDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// TaskInsert provides a mock function with given fields: _a0
func (_m *MockStore) TaskInsert(_a0 *model.Task) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Task) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// TaskInsert is a helper method to define mock.On call
//   - _a0 *model.Task
func (_e *MockStore_Expecter) TaskInsert(_a0 interface{}) *MockStore_TaskInsert_Call {
	return &MockStore_TaskInsert_Call{Call: _e.mock.On("TaskInsert", _a0)}
}

func (_c *MockStore_TaskInsert_Call) Run(run func(_a0 *model.Task)) *MockStore_TaskInsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Task))
	})
	return _c
}

func (_c *MockStore_TaskInsert_Call) Return(_a0 error) *MockStore_TaskInsert_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_TaskInsert_Call) RunAndReturn(run func(*model.Task) error) *MockStore_TaskInsert_Call {
	_c.Call.Return(run)
	return _c
}

// TaskList provides a mock function with no fields
func (_m *MockStore) TaskList() ([]*model.Task, error) {
	ret := _m.Called()

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

	var r0 []*model.Task
	var r1 error
	if rf, ok := ret.Get(0).(func() ([]*model.Task, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() []*model.Task); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Task)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TaskList is a helper method to define mock.On call
func (_e *MockStore_Expecter) TaskList() *MockStore_TaskList_Call {
	return &MockStore_TaskList_Call{Call: _e.mock.On("TaskList")}
}

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

func (_c *MockStore_TaskList_Call) Return(_a0 []*model.Task, _a1 error) *MockStore_TaskList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_TaskList_Call) RunAndReturn(run func() ([]*model.Task, error)) *MockStore_TaskList_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePipeline provides a mock function with given fields: _a0
func (_m *MockStore) UpdatePipeline(_a0 *model.Pipeline) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdatePipeline is a helper method to define mock.On call
//   - _a0 *model.Pipeline
func (_e *MockStore_Expecter) UpdatePipeline(_a0 interface{}) *MockStore_UpdatePipeline_Call {
	return &MockStore_UpdatePipeline_Call{Call: _e.mock.On("UpdatePipeline", _a0)}
}

func (_c *MockStore_UpdatePipeline_Call) Run(run func(_a0 *model.Pipeline)) *MockStore_UpdatePipeline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline))
	})
	return _c
}

func (_c *MockStore_UpdatePipeline_Call) Return(_a0 error) *MockStore_UpdatePipeline_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_UpdatePipeline_Call) RunAndReturn(run func(*model.Pipeline) error) *MockStore_UpdatePipeline_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRepo provides a mock function with given fields: _a0
func (_m *MockStore) UpdateRepo(_a0 *model.Repo) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateRepo is a helper method to define mock.On call
//   - _a0 *model.Repo
func (_e *MockStore_Expecter) UpdateRepo(_a0 interface{}) *MockStore_UpdateRepo_Call {
	return &MockStore_UpdateRepo_Call{Call: _e.mock.On("UpdateRepo", _a0)}
}

func (_c *MockStore_UpdateRepo_Call) Run(run func(_a0 *model.Repo)) *MockStore_UpdateRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Repo))
	})
	return _c
}

func (_c *MockStore_UpdateRepo_Call) Return(_a0 error) *MockStore_UpdateRepo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_UpdateRepo_Call) RunAndReturn(run func(*model.Repo) error) *MockStore_UpdateRepo_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUser provides a mock function with given fields: _a0
func (_m *MockStore) UpdateUser(_a0 *model.User) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.User) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateUser is a helper method to define mock.On call
//   - _a0 *model.User
func (_e *MockStore_Expecter) UpdateUser(_a0 interface{}) *MockStore_UpdateUser_Call {
	return &MockStore_UpdateUser_Call{Call: _e.mock.On("UpdateUser", _a0)}
}

func (_c *MockStore_UpdateUser_Call) Run(run func(_a0 *model.User)) *MockStore_UpdateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User))
	})
	return _c
}

func (_c *MockStore_UpdateUser_Call) Return(_a0 error) *MockStore_UpdateUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_UpdateUser_Call) RunAndReturn(run func(*model.User) error) *MockStore_UpdateUser_Call {
	_c.Call.Return(run)
	return _c
}

// UserFeed provides a mock function with given fields: _a0
func (_m *MockStore) UserFeed(_a0 *model.User) ([]*model.Feed, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Feed
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.User) ([]*model.Feed, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.User) []*model.Feed); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Feed)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.User) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UserFeed is a helper method to define mock.On call
//   - _a0 *model.User
func (_e *MockStore_Expecter) UserFeed(_a0 interface{}) *MockStore_UserFeed_Call {
	return &MockStore_UserFeed_Call{Call: _e.mock.On("UserFeed", _a0)}
}

func (_c *MockStore_UserFeed_Call) Run(run func(_a0 *model.User)) *MockStore_UserFeed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.User))
	})
	return _c
}

func (_c *MockStore_UserFeed_Call) Return(_a0 []*model.Feed, _a1 error) *MockStore_UserFeed_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_UserFeed_Call) RunAndReturn(run func(*model.User) ([]*model.Feed, error)) *MockStore_UserFeed_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowGetTree provides a mock function with given fields: _a0
func (_m *MockStore) WorkflowGetTree(_a0 *model.Pipeline) ([]*model.Workflow, error) {
	ret := _m.Called(_a0)

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

	var r0 []*model.Workflow
	var r1 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline) ([]*model.Workflow, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*model.Pipeline) []*model.Workflow); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*model.Workflow)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WorkflowGetTree is a helper method to define mock.On call
//   - _a0 *model.Pipeline
func (_e *MockStore_Expecter) WorkflowGetTree(_a0 interface{}) *MockStore_WorkflowGetTree_Call {
	return &MockStore_WorkflowGetTree_Call{Call: _e.mock.On("WorkflowGetTree", _a0)}
}

func (_c *MockStore_WorkflowGetTree_Call) Run(run func(_a0 *model.Pipeline)) *MockStore_WorkflowGetTree_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline))
	})
	return _c
}

func (_c *MockStore_WorkflowGetTree_Call) Return(_a0 []*model.Workflow, _a1 error) *MockStore_WorkflowGetTree_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_WorkflowGetTree_Call) RunAndReturn(run func(*model.Pipeline) ([]*model.Workflow, error)) *MockStore_WorkflowGetTree_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowLoad provides a mock function with given fields: _a0
func (_m *MockStore) WorkflowLoad(_a0 int64) (*model.Workflow, error) {
	ret := _m.Called(_a0)

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

	var r0 *model.Workflow
	var r1 error
	if rf, ok := ret.Get(0).(func(int64) (*model.Workflow, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(int64) *model.Workflow); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.Workflow)
		}
	}

	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WorkflowLoad is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockStore_Expecter) WorkflowLoad(_a0 interface{}) *MockStore_WorkflowLoad_Call {
	return &MockStore_WorkflowLoad_Call{Call: _e.mock.On("WorkflowLoad", _a0)}
}

func (_c *MockStore_WorkflowLoad_Call) Run(run func(_a0 int64)) *MockStore_WorkflowLoad_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockStore_WorkflowLoad_Call) Return(_a0 *model.Workflow, _a1 error) *MockStore_WorkflowLoad_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStore_WorkflowLoad_Call) RunAndReturn(run func(int64) (*model.Workflow, error)) *MockStore_WorkflowLoad_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowUpdate provides a mock function with given fields: _a0
func (_m *MockStore) WorkflowUpdate(_a0 *model.Workflow) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Workflow) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// WorkflowUpdate is a helper method to define mock.On call
//   - _a0 *model.Workflow
func (_e *MockStore_Expecter) WorkflowUpdate(_a0 interface{}) *MockStore_WorkflowUpdate_Call {
	return &MockStore_WorkflowUpdate_Call{Call: _e.mock.On("WorkflowUpdate", _a0)}
}

func (_c *MockStore_WorkflowUpdate_Call) Run(run func(_a0 *model.Workflow)) *MockStore_WorkflowUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Workflow))
	})
	return _c
}

func (_c *MockStore_WorkflowUpdate_Call) Return(_a0 error) *MockStore_WorkflowUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_WorkflowUpdate_Call) RunAndReturn(run func(*model.Workflow) error) *MockStore_WorkflowUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowsCreate provides a mock function with given fields: _a0
func (_m *MockStore) WorkflowsCreate(_a0 []*model.Workflow) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func([]*model.Workflow) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// WorkflowsCreate is a helper method to define mock.On call
//   - _a0 []*model.Workflow
func (_e *MockStore_Expecter) WorkflowsCreate(_a0 interface{}) *MockStore_WorkflowsCreate_Call {
	return &MockStore_WorkflowsCreate_Call{Call: _e.mock.On("WorkflowsCreate", _a0)}
}

func (_c *MockStore_WorkflowsCreate_Call) Run(run func(_a0 []*model.Workflow)) *MockStore_WorkflowsCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]*model.Workflow))
	})
	return _c
}

func (_c *MockStore_WorkflowsCreate_Call) Return(_a0 error) *MockStore_WorkflowsCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_WorkflowsCreate_Call) RunAndReturn(run func([]*model.Workflow) error) *MockStore_WorkflowsCreate_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowsReplace provides a mock function with given fields: _a0, _a1
func (_m *MockStore) WorkflowsReplace(_a0 *model.Pipeline, _a1 []*model.Workflow) error {
	ret := _m.Called(_a0, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*model.Pipeline, []*model.Workflow) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// WorkflowsReplace is a helper method to define mock.On call
//   - _a0 *model.Pipeline
//   - _a1 []*model.Workflow
func (_e *MockStore_Expecter) WorkflowsReplace(_a0 interface{}, _a1 interface{}) *MockStore_WorkflowsReplace_Call {
	return &MockStore_WorkflowsReplace_Call{Call: _e.mock.On("WorkflowsReplace", _a0, _a1)}
}

func (_c *MockStore_WorkflowsReplace_Call) Run(run func(_a0 *model.Pipeline, _a1 []*model.Workflow)) *MockStore_WorkflowsReplace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.Pipeline), args[1].([]*model.Workflow))
	})
	return _c
}

func (_c *MockStore_WorkflowsReplace_Call) Return(_a0 error) *MockStore_WorkflowsReplace_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStore_WorkflowsReplace_Call) RunAndReturn(run func(*model.Pipeline, []*model.Workflow) error) *MockStore_WorkflowsReplace_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}