// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/drone/drone/core (interfaces: NetrcService,Renewer,HookParser,UserService,RepositoryService,CommitService,StatusService,HookService,FileService,Batcher,BuildStore,CronStore,LogStore,PermStore,SecretStore,GlobalSecretStore,StageStore,StepStore,RepositoryStore,UserStore,Scheduler,Session,OrganizationService,SecretService,RegistryService,ConfigService,Triggerer,Syncer,LogStream,WebhookSender,LicenseService)

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	core "github.com/drone/drone/core"
	gomock "github.com/golang/mock/gomock"
	io "io"
	http "net/http"
	reflect "reflect"
)

// MockNetrcService is a mock of NetrcService interface
type MockNetrcService struct {
	ctrl     *gomock.Controller
	recorder *MockNetrcServiceMockRecorder
}

// MockNetrcServiceMockRecorder is the mock recorder for MockNetrcService
type MockNetrcServiceMockRecorder struct {
	mock *MockNetrcService
}

// NewMockNetrcService creates a new mock instance
func NewMockNetrcService(ctrl *gomock.Controller) *MockNetrcService {
	mock := &MockNetrcService{ctrl: ctrl}
	mock.recorder = &MockNetrcServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockNetrcService) EXPECT() *MockNetrcServiceMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockNetrcService) Create(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) (*core.Netrc, error) {
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Netrc)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create
func (mr *MockNetrcServiceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockNetrcService)(nil).Create), arg0, arg1, arg2)
}

// MockRenewer is a mock of Renewer interface
type MockRenewer struct {
	ctrl     *gomock.Controller
	recorder *MockRenewerMockRecorder
}

// MockRenewerMockRecorder is the mock recorder for MockRenewer
type MockRenewerMockRecorder struct {
	mock *MockRenewer
}

// NewMockRenewer creates a new mock instance
func NewMockRenewer(ctrl *gomock.Controller) *MockRenewer {
	mock := &MockRenewer{ctrl: ctrl}
	mock.recorder = &MockRenewerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRenewer) EXPECT() *MockRenewerMockRecorder {
	return m.recorder
}

// Renew mocks base method
func (m *MockRenewer) Renew(arg0 context.Context, arg1 *core.User, arg2 bool) error {
	ret := m.ctrl.Call(m, "Renew", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Renew indicates an expected call of Renew
func (mr *MockRenewerMockRecorder) Renew(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Renew", reflect.TypeOf((*MockRenewer)(nil).Renew), arg0, arg1, arg2)
}

// MockHookParser is a mock of HookParser interface
type MockHookParser struct {
	ctrl     *gomock.Controller
	recorder *MockHookParserMockRecorder
}

// MockHookParserMockRecorder is the mock recorder for MockHookParser
type MockHookParserMockRecorder struct {
	mock *MockHookParser
}

// NewMockHookParser creates a new mock instance
func NewMockHookParser(ctrl *gomock.Controller) *MockHookParser {
	mock := &MockHookParser{ctrl: ctrl}
	mock.recorder = &MockHookParserMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockHookParser) EXPECT() *MockHookParserMockRecorder {
	return m.recorder
}

// Parse mocks base method
func (m *MockHookParser) Parse(arg0 *http.Request, arg1 func(string) string) (*core.Hook, *core.Repository, error) {
	ret := m.ctrl.Call(m, "Parse", arg0, arg1)
	ret0, _ := ret[0].(*core.Hook)
	ret1, _ := ret[1].(*core.Repository)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Parse indicates an expected call of Parse
func (mr *MockHookParserMockRecorder) Parse(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockHookParser)(nil).Parse), arg0, arg1)
}

// MockUserService is a mock of UserService interface
type MockUserService struct {
	ctrl     *gomock.Controller
	recorder *MockUserServiceMockRecorder
}

// MockUserServiceMockRecorder is the mock recorder for MockUserService
type MockUserServiceMockRecorder struct {
	mock *MockUserService
}

// NewMockUserService creates a new mock instance
func NewMockUserService(ctrl *gomock.Controller) *MockUserService {
	mock := &MockUserService{ctrl: ctrl}
	mock.recorder = &MockUserServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockUserService) EXPECT() *MockUserServiceMockRecorder {
	return m.recorder
}

// Find mocks base method
func (m *MockUserService) Find(arg0 context.Context, arg1, arg2 string) (*core.User, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockUserServiceMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserService)(nil).Find), arg0, arg1, arg2)
}

// MockRepositoryService is a mock of RepositoryService interface
type MockRepositoryService struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryServiceMockRecorder
}

// MockRepositoryServiceMockRecorder is the mock recorder for MockRepositoryService
type MockRepositoryServiceMockRecorder struct {
	mock *MockRepositoryService
}

// NewMockRepositoryService creates a new mock instance
func NewMockRepositoryService(ctrl *gomock.Controller) *MockRepositoryService {
	mock := &MockRepositoryService{ctrl: ctrl}
	mock.recorder = &MockRepositoryServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRepositoryService) EXPECT() *MockRepositoryServiceMockRecorder {
	return m.recorder
}

// Find mocks base method
func (m *MockRepositoryService) Find(arg0 context.Context, arg1 *core.User, arg2 string) (*core.Repository, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockRepositoryServiceMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRepositoryService)(nil).Find), arg0, arg1, arg2)
}

// FindPerm mocks base method
func (m *MockRepositoryService) FindPerm(arg0 context.Context, arg1 *core.User, arg2 string) (*core.Perm, error) {
	ret := m.ctrl.Call(m, "FindPerm", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindPerm indicates an expected call of FindPerm
func (mr *MockRepositoryServiceMockRecorder) FindPerm(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPerm", reflect.TypeOf((*MockRepositoryService)(nil).FindPerm), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockRepositoryService) List(arg0 context.Context, arg1 *core.User) ([]*core.Repository, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockRepositoryServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositoryService)(nil).List), arg0, arg1)
}

// MockCommitService is a mock of CommitService interface
type MockCommitService struct {
	ctrl     *gomock.Controller
	recorder *MockCommitServiceMockRecorder
}

// MockCommitServiceMockRecorder is the mock recorder for MockCommitService
type MockCommitServiceMockRecorder struct {
	mock *MockCommitService
}

// NewMockCommitService creates a new mock instance
func NewMockCommitService(ctrl *gomock.Controller) *MockCommitService {
	mock := &MockCommitService{ctrl: ctrl}
	mock.recorder = &MockCommitServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockCommitService) EXPECT() *MockCommitServiceMockRecorder {
	return m.recorder
}

// Find mocks base method
func (m *MockCommitService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3 string) (*core.Commit, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*core.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockCommitServiceMockRecorder) Find(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCommitService)(nil).Find), arg0, arg1, arg2, arg3)
}

// FindRef mocks base method
func (m *MockCommitService) FindRef(arg0 context.Context, arg1 *core.User, arg2, arg3 string) (*core.Commit, error) {
	ret := m.ctrl.Call(m, "FindRef", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*core.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRef indicates an expected call of FindRef
func (mr *MockCommitServiceMockRecorder) FindRef(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRef", reflect.TypeOf((*MockCommitService)(nil).FindRef), arg0, arg1, arg2, arg3)
}

// ListChanges mocks base method
func (m *MockCommitService) ListChanges(arg0 context.Context, arg1 *core.User, arg2, arg3, arg4 string) ([]*core.Change, error) {
	ret := m.ctrl.Call(m, "ListChanges", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*core.Change)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChanges indicates an expected call of ListChanges
func (mr *MockCommitServiceMockRecorder) ListChanges(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChanges", reflect.TypeOf((*MockCommitService)(nil).ListChanges), arg0, arg1, arg2, arg3, arg4)
}

// MockStatusService is a mock of StatusService interface
type MockStatusService struct {
	ctrl     *gomock.Controller
	recorder *MockStatusServiceMockRecorder
}

// MockStatusServiceMockRecorder is the mock recorder for MockStatusService
type MockStatusServiceMockRecorder struct {
	mock *MockStatusService
}

// NewMockStatusService creates a new mock instance
func NewMockStatusService(ctrl *gomock.Controller) *MockStatusService {
	mock := &MockStatusService{ctrl: ctrl}
	mock.recorder = &MockStatusServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockStatusService) EXPECT() *MockStatusServiceMockRecorder {
	return m.recorder
}

// Send mocks base method
func (m *MockStatusService) Send(arg0 context.Context, arg1 *core.User, arg2 *core.StatusInput) error {
	ret := m.ctrl.Call(m, "Send", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send
func (mr *MockStatusServiceMockRecorder) Send(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockStatusService)(nil).Send), arg0, arg1, arg2)
}

// MockHookService is a mock of HookService interface
type MockHookService struct {
	ctrl     *gomock.Controller
	recorder *MockHookServiceMockRecorder
}

// MockHookServiceMockRecorder is the mock recorder for MockHookService
type MockHookServiceMockRecorder struct {
	mock *MockHookService
}

// NewMockHookService creates a new mock instance
func NewMockHookService(ctrl *gomock.Controller) *MockHookService {
	mock := &MockHookService{ctrl: ctrl}
	mock.recorder = &MockHookServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockHookService) EXPECT() *MockHookServiceMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockHookService) Create(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockHookServiceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockHookService)(nil).Create), arg0, arg1, arg2)
}

// Delete mocks base method
func (m *MockHookService) Delete(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockHookServiceMockRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockHookService)(nil).Delete), arg0, arg1, arg2)
}

// MockFileService is a mock of FileService interface
type MockFileService struct {
	ctrl     *gomock.Controller
	recorder *MockFileServiceMockRecorder
}

// MockFileServiceMockRecorder is the mock recorder for MockFileService
type MockFileServiceMockRecorder struct {
	mock *MockFileService
}

// NewMockFileService creates a new mock instance
func NewMockFileService(ctrl *gomock.Controller) *MockFileService {
	mock := &MockFileService{ctrl: ctrl}
	mock.recorder = &MockFileServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockFileService) EXPECT() *MockFileServiceMockRecorder {
	return m.recorder
}

// Find mocks base method
func (m *MockFileService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3, arg4, arg5 string) (*core.File, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*core.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockFileServiceMockRecorder) Find(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockFileService)(nil).Find), arg0, arg1, arg2, arg3, arg4, arg5)
}

// MockBatcher is a mock of Batcher interface
type MockBatcher struct {
	ctrl     *gomock.Controller
	recorder *MockBatcherMockRecorder
}

// MockBatcherMockRecorder is the mock recorder for MockBatcher
type MockBatcherMockRecorder struct {
	mock *MockBatcher
}

// NewMockBatcher creates a new mock instance
func NewMockBatcher(ctrl *gomock.Controller) *MockBatcher {
	mock := &MockBatcher{ctrl: ctrl}
	mock.recorder = &MockBatcherMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockBatcher) EXPECT() *MockBatcherMockRecorder {
	return m.recorder
}

// Batch mocks base method
func (m *MockBatcher) Batch(arg0 context.Context, arg1 *core.User, arg2 *core.Batch) error {
	ret := m.ctrl.Call(m, "Batch", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Batch indicates an expected call of Batch
func (mr *MockBatcherMockRecorder) Batch(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Batch", reflect.TypeOf((*MockBatcher)(nil).Batch), arg0, arg1, arg2)
}

// MockBuildStore is a mock of BuildStore interface
type MockBuildStore struct {
	ctrl     *gomock.Controller
	recorder *MockBuildStoreMockRecorder
}

// MockBuildStoreMockRecorder is the mock recorder for MockBuildStore
type MockBuildStoreMockRecorder struct {
	mock *MockBuildStore
}

// NewMockBuildStore creates a new mock instance
func NewMockBuildStore(ctrl *gomock.Controller) *MockBuildStore {
	mock := &MockBuildStore{ctrl: ctrl}
	mock.recorder = &MockBuildStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockBuildStore) EXPECT() *MockBuildStoreMockRecorder {
	return m.recorder
}

// Count mocks base method
func (m *MockBuildStore) Count(arg0 context.Context) (int64, error) {
	ret := m.ctrl.Call(m, "Count", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Count indicates an expected call of Count
func (mr *MockBuildStoreMockRecorder) Count(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockBuildStore)(nil).Count), arg0)
}

// Create mocks base method
func (m *MockBuildStore) Create(arg0 context.Context, arg1 *core.Build, arg2 []*core.Stage) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockBuildStoreMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockBuildStore)(nil).Create), arg0, arg1, arg2)
}

// Delete mocks base method
func (m *MockBuildStore) Delete(arg0 context.Context, arg1 *core.Build) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockBuildStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBuildStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockBuildStore) Find(arg0 context.Context, arg1 int64) (*core.Build, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockBuildStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockBuildStore)(nil).Find), arg0, arg1)
}

// FindNumber mocks base method
func (m *MockBuildStore) FindNumber(arg0 context.Context, arg1, arg2 int64) (*core.Build, error) {
	ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindNumber indicates an expected call of FindNumber
func (mr *MockBuildStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockBuildStore)(nil).FindNumber), arg0, arg1, arg2)
}

// FindRef mocks base method
func (m *MockBuildStore) FindRef(arg0 context.Context, arg1 int64, arg2 string) (*core.Build, error) {
	ret := m.ctrl.Call(m, "FindRef", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRef indicates an expected call of FindRef
func (mr *MockBuildStoreMockRecorder) FindRef(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRef", reflect.TypeOf((*MockBuildStore)(nil).FindRef), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockBuildStore) List(arg0 context.Context, arg1 int64, arg2, arg3 int) ([]*core.Build, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockBuildStoreMockRecorder) List(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockBuildStore)(nil).List), arg0, arg1, arg2, arg3)
}

// ListRef mocks base method
func (m *MockBuildStore) ListRef(arg0 context.Context, arg1 int64, arg2 string, arg3, arg4 int) ([]*core.Build, error) {
	ret := m.ctrl.Call(m, "ListRef", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRef indicates an expected call of ListRef
func (mr *MockBuildStoreMockRecorder) ListRef(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRef", reflect.TypeOf((*MockBuildStore)(nil).ListRef), arg0, arg1, arg2, arg3, arg4)
}

// Pending mocks base method
func (m *MockBuildStore) Pending(arg0 context.Context) ([]*core.Build, error) {
	ret := m.ctrl.Call(m, "Pending", arg0)
	ret0, _ := ret[0].([]*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pending indicates an expected call of Pending
func (mr *MockBuildStoreMockRecorder) Pending(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockBuildStore)(nil).Pending), arg0)
}

// Purge mocks base method
func (m *MockBuildStore) Purge(arg0 context.Context, arg1, arg2 int64) error {
	ret := m.ctrl.Call(m, "Purge", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Purge indicates an expected call of Purge
func (mr *MockBuildStoreMockRecorder) Purge(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Purge", reflect.TypeOf((*MockBuildStore)(nil).Purge), arg0, arg1, arg2)
}

// Running mocks base method
func (m *MockBuildStore) Running(arg0 context.Context) ([]*core.Build, error) {
	ret := m.ctrl.Call(m, "Running", arg0)
	ret0, _ := ret[0].([]*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Running indicates an expected call of Running
func (mr *MockBuildStoreMockRecorder) Running(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Running", reflect.TypeOf((*MockBuildStore)(nil).Running), arg0)
}

// Update mocks base method
func (m *MockBuildStore) Update(arg0 context.Context, arg1 *core.Build) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockBuildStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockBuildStore)(nil).Update), arg0, arg1)
}

// MockCronStore is a mock of CronStore interface
type MockCronStore struct {
	ctrl     *gomock.Controller
	recorder *MockCronStoreMockRecorder
}

// MockCronStoreMockRecorder is the mock recorder for MockCronStore
type MockCronStoreMockRecorder struct {
	mock *MockCronStore
}

// NewMockCronStore creates a new mock instance
func NewMockCronStore(ctrl *gomock.Controller) *MockCronStore {
	mock := &MockCronStore{ctrl: ctrl}
	mock.recorder = &MockCronStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockCronStore) EXPECT() *MockCronStoreMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockCronStore) Create(arg0 context.Context, arg1 *core.Cron) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockCronStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockCronStore)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockCronStore) Delete(arg0 context.Context, arg1 *core.Cron) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockCronStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCronStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockCronStore) Find(arg0 context.Context, arg1 int64) (*core.Cron, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Cron)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockCronStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCronStore)(nil).Find), arg0, arg1)
}

// FindName mocks base method
func (m *MockCronStore) FindName(arg0 context.Context, arg1 int64, arg2 string) (*core.Cron, error) {
	ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Cron)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindName indicates an expected call of FindName
func (mr *MockCronStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockCronStore)(nil).FindName), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockCronStore) List(arg0 context.Context, arg1 int64) ([]*core.Cron, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Cron)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockCronStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCronStore)(nil).List), arg0, arg1)
}

// Ready mocks base method
func (m *MockCronStore) Ready(arg0 context.Context, arg1 int64) ([]*core.Cron, error) {
	ret := m.ctrl.Call(m, "Ready", arg0, arg1)
	ret0, _ := ret[0].([]*core.Cron)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ready indicates an expected call of Ready
func (mr *MockCronStoreMockRecorder) Ready(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockCronStore)(nil).Ready), arg0, arg1)
}

// Update mocks base method
func (m *MockCronStore) Update(arg0 context.Context, arg1 *core.Cron) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockCronStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCronStore)(nil).Update), arg0, arg1)
}

// MockLogStore is a mock of LogStore interface
type MockLogStore struct {
	ctrl     *gomock.Controller
	recorder *MockLogStoreMockRecorder
}

// MockLogStoreMockRecorder is the mock recorder for MockLogStore
type MockLogStoreMockRecorder struct {
	mock *MockLogStore
}

// NewMockLogStore creates a new mock instance
func NewMockLogStore(ctrl *gomock.Controller) *MockLogStore {
	mock := &MockLogStore{ctrl: ctrl}
	mock.recorder = &MockLogStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockLogStore) EXPECT() *MockLogStoreMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockLogStore) Create(arg0 context.Context, arg1 int64, arg2 io.Reader) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockLogStoreMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLogStore)(nil).Create), arg0, arg1, arg2)
}

// Delete mocks base method
func (m *MockLogStore) Delete(arg0 context.Context, arg1 int64) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockLogStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLogStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockLogStore) Find(arg0 context.Context, arg1 int64) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockLogStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockLogStore)(nil).Find), arg0, arg1)
}

// Update mocks base method
func (m *MockLogStore) Update(arg0 context.Context, arg1 int64, arg2 io.Reader) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockLogStoreMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLogStore)(nil).Update), arg0, arg1, arg2)
}

// MockPermStore is a mock of PermStore interface
type MockPermStore struct {
	ctrl     *gomock.Controller
	recorder *MockPermStoreMockRecorder
}

// MockPermStoreMockRecorder is the mock recorder for MockPermStore
type MockPermStoreMockRecorder struct {
	mock *MockPermStore
}

// NewMockPermStore creates a new mock instance
func NewMockPermStore(ctrl *gomock.Controller) *MockPermStore {
	mock := &MockPermStore{ctrl: ctrl}
	mock.recorder = &MockPermStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockPermStore) EXPECT() *MockPermStoreMockRecorder {
	return m.recorder
}

// Delete mocks base method
func (m *MockPermStore) Delete(arg0 context.Context, arg1 *core.Perm) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockPermStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPermStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockPermStore) Find(arg0 context.Context, arg1 string, arg2 int64) (*core.Perm, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockPermStoreMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockPermStore)(nil).Find), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockPermStore) List(arg0 context.Context, arg1 string) ([]*core.Collaborator, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Collaborator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockPermStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPermStore)(nil).List), arg0, arg1)
}

// Update mocks base method
func (m *MockPermStore) Update(arg0 context.Context, arg1 *core.Perm) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockPermStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockPermStore)(nil).Update), arg0, arg1)
}

// MockSecretStore is a mock of SecretStore interface
type MockSecretStore struct {
	ctrl     *gomock.Controller
	recorder *MockSecretStoreMockRecorder
}

// MockSecretStoreMockRecorder is the mock recorder for MockSecretStore
type MockSecretStoreMockRecorder struct {
	mock *MockSecretStore
}

// NewMockSecretStore creates a new mock instance
func NewMockSecretStore(ctrl *gomock.Controller) *MockSecretStore {
	mock := &MockSecretStore{ctrl: ctrl}
	mock.recorder = &MockSecretStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSecretStore) EXPECT() *MockSecretStoreMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockSecretStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSecretStore)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockSecretStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSecretStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockSecretStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockSecretStore)(nil).Find), arg0, arg1)
}

// FindName mocks base method
func (m *MockSecretStore) FindName(arg0 context.Context, arg1 int64, arg2 string) (*core.Secret, error) {
	ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindName indicates an expected call of FindName
func (mr *MockSecretStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockSecretStore)(nil).FindName), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockSecretStore) List(arg0 context.Context, arg1 int64) ([]*core.Secret, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockSecretStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSecretStore)(nil).List), arg0, arg1)
}

// Update mocks base method
func (m *MockSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockSecretStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSecretStore)(nil).Update), arg0, arg1)
}

// MockGlobalSecretStore is a mock of GlobalSecretStore interface
type MockGlobalSecretStore struct {
	ctrl     *gomock.Controller
	recorder *MockGlobalSecretStoreMockRecorder
}

// MockGlobalSecretStoreMockRecorder is the mock recorder for MockGlobalSecretStore
type MockGlobalSecretStoreMockRecorder struct {
	mock *MockGlobalSecretStore
}

// NewMockGlobalSecretStore creates a new mock instance
func NewMockGlobalSecretStore(ctrl *gomock.Controller) *MockGlobalSecretStore {
	mock := &MockGlobalSecretStore{ctrl: ctrl}
	mock.recorder = &MockGlobalSecretStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGlobalSecretStore) EXPECT() *MockGlobalSecretStoreMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockGlobalSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockGlobalSecretStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockGlobalSecretStore)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockGlobalSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockGlobalSecretStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockGlobalSecretStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockGlobalSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockGlobalSecretStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockGlobalSecretStore)(nil).Find), arg0, arg1)
}

// FindName mocks base method
func (m *MockGlobalSecretStore) FindName(arg0 context.Context, arg1, arg2 string) (*core.Secret, error) {
	ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindName indicates an expected call of FindName
func (mr *MockGlobalSecretStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockGlobalSecretStore)(nil).FindName), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockGlobalSecretStore) List(arg0 context.Context, arg1 string) ([]*core.Secret, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockGlobalSecretStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockGlobalSecretStore)(nil).List), arg0, arg1)
}

// ListAll mocks base method
func (m *MockGlobalSecretStore) ListAll(arg0 context.Context) ([]*core.Secret, error) {
	ret := m.ctrl.Call(m, "ListAll", arg0)
	ret0, _ := ret[0].([]*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAll indicates an expected call of ListAll
func (mr *MockGlobalSecretStoreMockRecorder) ListAll(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAll", reflect.TypeOf((*MockGlobalSecretStore)(nil).ListAll), arg0)
}

// Update mocks base method
func (m *MockGlobalSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockGlobalSecretStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGlobalSecretStore)(nil).Update), arg0, arg1)
}

// MockStageStore is a mock of StageStore interface
type MockStageStore struct {
	ctrl     *gomock.Controller
	recorder *MockStageStoreMockRecorder
}

// MockStageStoreMockRecorder is the mock recorder for MockStageStore
type MockStageStoreMockRecorder struct {
	mock *MockStageStore
}

// NewMockStageStore creates a new mock instance
func NewMockStageStore(ctrl *gomock.Controller) *MockStageStore {
	mock := &MockStageStore{ctrl: ctrl}
	mock.recorder = &MockStageStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockStageStore) EXPECT() *MockStageStoreMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockStageStore) Create(arg0 context.Context, arg1 *core.Stage) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockStageStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStageStore)(nil).Create), arg0, arg1)
}

// Find mocks base method
func (m *MockStageStore) Find(arg0 context.Context, arg1 int64) (*core.Stage, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockStageStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStageStore)(nil).Find), arg0, arg1)
}

// FindNumber mocks base method
func (m *MockStageStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) (*core.Stage, error) {
	ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindNumber indicates an expected call of FindNumber
func (mr *MockStageStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockStageStore)(nil).FindNumber), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockStageStore) List(arg0 context.Context, arg1 int64) ([]*core.Stage, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockStageStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStageStore)(nil).List), arg0, arg1)
}

// ListIncomplete mocks base method
func (m *MockStageStore) ListIncomplete(arg0 context.Context) ([]*core.Stage, error) {
	ret := m.ctrl.Call(m, "ListIncomplete", arg0)
	ret0, _ := ret[0].([]*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIncomplete indicates an expected call of ListIncomplete
func (mr *MockStageStoreMockRecorder) ListIncomplete(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncomplete", reflect.TypeOf((*MockStageStore)(nil).ListIncomplete), arg0)
}

// ListState mocks base method
func (m *MockStageStore) ListState(arg0 context.Context, arg1 string) ([]*core.Stage, error) {
	ret := m.ctrl.Call(m, "ListState", arg0, arg1)
	ret0, _ := ret[0].([]*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListState indicates an expected call of ListState
func (mr *MockStageStoreMockRecorder) ListState(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListState", reflect.TypeOf((*MockStageStore)(nil).ListState), arg0, arg1)
}

// ListSteps mocks base method
func (m *MockStageStore) ListSteps(arg0 context.Context, arg1 int64) ([]*core.Stage, error) {
	ret := m.ctrl.Call(m, "ListSteps", arg0, arg1)
	ret0, _ := ret[0].([]*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSteps indicates an expected call of ListSteps
func (mr *MockStageStoreMockRecorder) ListSteps(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSteps", reflect.TypeOf((*MockStageStore)(nil).ListSteps), arg0, arg1)
}

// Update mocks base method
func (m *MockStageStore) Update(arg0 context.Context, arg1 *core.Stage) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockStageStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStageStore)(nil).Update), arg0, arg1)
}

// MockStepStore is a mock of StepStore interface
type MockStepStore struct {
	ctrl     *gomock.Controller
	recorder *MockStepStoreMockRecorder
}

// MockStepStoreMockRecorder is the mock recorder for MockStepStore
type MockStepStoreMockRecorder struct {
	mock *MockStepStore
}

// NewMockStepStore creates a new mock instance
func NewMockStepStore(ctrl *gomock.Controller) *MockStepStore {
	mock := &MockStepStore{ctrl: ctrl}
	mock.recorder = &MockStepStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockStepStore) EXPECT() *MockStepStoreMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockStepStore) Create(arg0 context.Context, arg1 *core.Step) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockStepStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStepStore)(nil).Create), arg0, arg1)
}

// Find mocks base method
func (m *MockStepStore) Find(arg0 context.Context, arg1 int64) (*core.Step, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Step)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockStepStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStepStore)(nil).Find), arg0, arg1)
}

// FindNumber mocks base method
func (m *MockStepStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) (*core.Step, error) {
	ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Step)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindNumber indicates an expected call of FindNumber
func (mr *MockStepStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockStepStore)(nil).FindNumber), arg0, arg1, arg2)
}

// List mocks base method
func (m *MockStepStore) List(arg0 context.Context, arg1 int64) ([]*core.Step, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Step)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockStepStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStepStore)(nil).List), arg0, arg1)
}

// Update mocks base method
func (m *MockStepStore) Update(arg0 context.Context, arg1 *core.Step) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockStepStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStepStore)(nil).Update), arg0, arg1)
}

// MockRepositoryStore is a mock of RepositoryStore interface
type MockRepositoryStore struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryStoreMockRecorder
}

// MockRepositoryStoreMockRecorder is the mock recorder for MockRepositoryStore
type MockRepositoryStoreMockRecorder struct {
	mock *MockRepositoryStore
}

// NewMockRepositoryStore creates a new mock instance
func NewMockRepositoryStore(ctrl *gomock.Controller) *MockRepositoryStore {
	mock := &MockRepositoryStore{ctrl: ctrl}
	mock.recorder = &MockRepositoryStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRepositoryStore) EXPECT() *MockRepositoryStoreMockRecorder {
	return m.recorder
}

// Activate mocks base method
func (m *MockRepositoryStore) Activate(arg0 context.Context, arg1 *core.Repository) error {
	ret := m.ctrl.Call(m, "Activate", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Activate indicates an expected call of Activate
func (mr *MockRepositoryStoreMockRecorder) Activate(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Activate", reflect.TypeOf((*MockRepositoryStore)(nil).Activate), arg0, arg1)
}

// Count mocks base method
func (m *MockRepositoryStore) Count(arg0 context.Context) (int64, error) {
	ret := m.ctrl.Call(m, "Count", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Count indicates an expected call of Count
func (mr *MockRepositoryStoreMockRecorder) Count(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockRepositoryStore)(nil).Count), arg0)
}

// Create mocks base method
func (m *MockRepositoryStore) Create(arg0 context.Context, arg1 *core.Repository) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockRepositoryStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepositoryStore)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockRepositoryStore) Delete(arg0 context.Context, arg1 *core.Repository) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockRepositoryStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepositoryStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockRepositoryStore) Find(arg0 context.Context, arg1 int64) (*core.Repository, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockRepositoryStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRepositoryStore)(nil).Find), arg0, arg1)
}

// FindName mocks base method
func (m *MockRepositoryStore) FindName(arg0 context.Context, arg1, arg2 string) (*core.Repository, error) {
	ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindName indicates an expected call of FindName
func (mr *MockRepositoryStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockRepositoryStore)(nil).FindName), arg0, arg1, arg2)
}

// Increment mocks base method
func (m *MockRepositoryStore) Increment(arg0 context.Context, arg1 *core.Repository) (*core.Repository, error) {
	ret := m.ctrl.Call(m, "Increment", arg0, arg1)
	ret0, _ := ret[0].(*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Increment indicates an expected call of Increment
func (mr *MockRepositoryStoreMockRecorder) Increment(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increment", reflect.TypeOf((*MockRepositoryStore)(nil).Increment), arg0, arg1)
}

// List mocks base method
func (m *MockRepositoryStore) List(arg0 context.Context, arg1 int64) ([]*core.Repository, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockRepositoryStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositoryStore)(nil).List), arg0, arg1)
}

// ListIncomplete mocks base method
func (m *MockRepositoryStore) ListIncomplete(arg0 context.Context) ([]*core.Repository, error) {
	ret := m.ctrl.Call(m, "ListIncomplete", arg0)
	ret0, _ := ret[0].([]*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIncomplete indicates an expected call of ListIncomplete
func (mr *MockRepositoryStoreMockRecorder) ListIncomplete(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncomplete", reflect.TypeOf((*MockRepositoryStore)(nil).ListIncomplete), arg0)
}

// ListLatest mocks base method
func (m *MockRepositoryStore) ListLatest(arg0 context.Context, arg1 int64) ([]*core.Repository, error) {
	ret := m.ctrl.Call(m, "ListLatest", arg0, arg1)
	ret0, _ := ret[0].([]*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLatest indicates an expected call of ListLatest
func (mr *MockRepositoryStoreMockRecorder) ListLatest(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLatest", reflect.TypeOf((*MockRepositoryStore)(nil).ListLatest), arg0, arg1)
}

// ListRecent mocks base method
func (m *MockRepositoryStore) ListRecent(arg0 context.Context, arg1 int64) ([]*core.Repository, error) {
	ret := m.ctrl.Call(m, "ListRecent", arg0, arg1)
	ret0, _ := ret[0].([]*core.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRecent indicates an expected call of ListRecent
func (mr *MockRepositoryStoreMockRecorder) ListRecent(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRecent", reflect.TypeOf((*MockRepositoryStore)(nil).ListRecent), arg0, arg1)
}

// Update mocks base method
func (m *MockRepositoryStore) Update(arg0 context.Context, arg1 *core.Repository) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockRepositoryStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRepositoryStore)(nil).Update), arg0, arg1)
}

// MockUserStore is a mock of UserStore interface
type MockUserStore struct {
	ctrl     *gomock.Controller
	recorder *MockUserStoreMockRecorder
}

// MockUserStoreMockRecorder is the mock recorder for MockUserStore
type MockUserStoreMockRecorder struct {
	mock *MockUserStore
}

// NewMockUserStore creates a new mock instance
func NewMockUserStore(ctrl *gomock.Controller) *MockUserStore {
	mock := &MockUserStore{ctrl: ctrl}
	mock.recorder = &MockUserStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockUserStore) EXPECT() *MockUserStoreMockRecorder {
	return m.recorder
}

// Count mocks base method
func (m *MockUserStore) Count(arg0 context.Context) (int64, error) {
	ret := m.ctrl.Call(m, "Count", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Count indicates an expected call of Count
func (mr *MockUserStoreMockRecorder) Count(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockUserStore)(nil).Count), arg0)
}

// Create mocks base method
func (m *MockUserStore) Create(arg0 context.Context, arg1 *core.User) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockUserStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserStore)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockUserStore) Delete(arg0 context.Context, arg1 *core.User) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockUserStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserStore)(nil).Delete), arg0, arg1)
}

// Find mocks base method
func (m *MockUserStore) Find(arg0 context.Context, arg1 int64) (*core.User, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockUserStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserStore)(nil).Find), arg0, arg1)
}

// FindLogin mocks base method
func (m *MockUserStore) FindLogin(arg0 context.Context, arg1 string) (*core.User, error) {
	ret := m.ctrl.Call(m, "FindLogin", arg0, arg1)
	ret0, _ := ret[0].(*core.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindLogin indicates an expected call of FindLogin
func (mr *MockUserStoreMockRecorder) FindLogin(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLogin", reflect.TypeOf((*MockUserStore)(nil).FindLogin), arg0, arg1)
}

// FindToken mocks base method
func (m *MockUserStore) FindToken(arg0 context.Context, arg1 string) (*core.User, error) {
	ret := m.ctrl.Call(m, "FindToken", arg0, arg1)
	ret0, _ := ret[0].(*core.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindToken indicates an expected call of FindToken
func (mr *MockUserStoreMockRecorder) FindToken(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindToken", reflect.TypeOf((*MockUserStore)(nil).FindToken), arg0, arg1)
}

// List mocks base method
func (m *MockUserStore) List(arg0 context.Context) ([]*core.User, error) {
	ret := m.ctrl.Call(m, "List", arg0)
	ret0, _ := ret[0].([]*core.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockUserStoreMockRecorder) List(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockUserStore)(nil).List), arg0)
}

// Update mocks base method
func (m *MockUserStore) Update(arg0 context.Context, arg1 *core.User) error {
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockUserStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserStore)(nil).Update), arg0, arg1)
}

// MockScheduler is a mock of Scheduler interface
type MockScheduler struct {
	ctrl     *gomock.Controller
	recorder *MockSchedulerMockRecorder
}

// MockSchedulerMockRecorder is the mock recorder for MockScheduler
type MockSchedulerMockRecorder struct {
	mock *MockScheduler
}

// NewMockScheduler creates a new mock instance
func NewMockScheduler(ctrl *gomock.Controller) *MockScheduler {
	mock := &MockScheduler{ctrl: ctrl}
	mock.recorder = &MockSchedulerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockScheduler) EXPECT() *MockSchedulerMockRecorder {
	return m.recorder
}

// Cancel mocks base method
func (m *MockScheduler) Cancel(arg0 context.Context, arg1 int64) error {
	ret := m.ctrl.Call(m, "Cancel", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Cancel indicates an expected call of Cancel
func (mr *MockSchedulerMockRecorder) Cancel(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockScheduler)(nil).Cancel), arg0, arg1)
}

// Cancelled mocks base method
func (m *MockScheduler) Cancelled(arg0 context.Context, arg1 int64) (bool, error) {
	ret := m.ctrl.Call(m, "Cancelled", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Cancelled indicates an expected call of Cancelled
func (mr *MockSchedulerMockRecorder) Cancelled(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancelled", reflect.TypeOf((*MockScheduler)(nil).Cancelled), arg0, arg1)
}

// Pause mocks base method
func (m *MockScheduler) Pause(arg0 context.Context) error {
	ret := m.ctrl.Call(m, "Pause", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Pause indicates an expected call of Pause
func (mr *MockSchedulerMockRecorder) Pause(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pause", reflect.TypeOf((*MockScheduler)(nil).Pause), arg0)
}

// Request mocks base method
func (m *MockScheduler) Request(arg0 context.Context, arg1 core.Filter) (*core.Stage, error) {
	ret := m.ctrl.Call(m, "Request", arg0, arg1)
	ret0, _ := ret[0].(*core.Stage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Request indicates an expected call of Request
func (mr *MockSchedulerMockRecorder) Request(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Request", reflect.TypeOf((*MockScheduler)(nil).Request), arg0, arg1)
}

// Resume mocks base method
func (m *MockScheduler) Resume(arg0 context.Context) error {
	ret := m.ctrl.Call(m, "Resume", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Resume indicates an expected call of Resume
func (mr *MockSchedulerMockRecorder) Resume(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resume", reflect.TypeOf((*MockScheduler)(nil).Resume), arg0)
}

// Schedule mocks base method
func (m *MockScheduler) Schedule(arg0 context.Context, arg1 *core.Stage) error {
	ret := m.ctrl.Call(m, "Schedule", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Schedule indicates an expected call of Schedule
func (mr *MockSchedulerMockRecorder) Schedule(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Schedule", reflect.TypeOf((*MockScheduler)(nil).Schedule), arg0, arg1)
}

// Stats mocks base method
func (m *MockScheduler) Stats(arg0 context.Context) (interface{}, error) {
	ret := m.ctrl.Call(m, "Stats", arg0)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stats indicates an expected call of Stats
func (mr *MockSchedulerMockRecorder) Stats(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockScheduler)(nil).Stats), arg0)
}

// MockSession is a mock of Session interface
type MockSession struct {
	ctrl     *gomock.Controller
	recorder *MockSessionMockRecorder
}

// MockSessionMockRecorder is the mock recorder for MockSession
type MockSessionMockRecorder struct {
	mock *MockSession
}

// NewMockSession creates a new mock instance
func NewMockSession(ctrl *gomock.Controller) *MockSession {
	mock := &MockSession{ctrl: ctrl}
	mock.recorder = &MockSessionMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSession) EXPECT() *MockSessionMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockSession) Create(arg0 http.ResponseWriter, arg1 *core.User) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockSessionMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSession)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockSession) Delete(arg0 http.ResponseWriter) error {
	ret := m.ctrl.Call(m, "Delete", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockSessionMockRecorder) Delete(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSession)(nil).Delete), arg0)
}

// Get mocks base method
func (m *MockSession) Get(arg0 *http.Request) (*core.User, error) {
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(*core.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get
func (mr *MockSessionMockRecorder) Get(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSession)(nil).Get), arg0)
}

// MockOrganizationService is a mock of OrganizationService interface
type MockOrganizationService struct {
	ctrl     *gomock.Controller
	recorder *MockOrganizationServiceMockRecorder
}

// MockOrganizationServiceMockRecorder is the mock recorder for MockOrganizationService
type MockOrganizationServiceMockRecorder struct {
	mock *MockOrganizationService
}

// NewMockOrganizationService creates a new mock instance
func NewMockOrganizationService(ctrl *gomock.Controller) *MockOrganizationService {
	mock := &MockOrganizationService{ctrl: ctrl}
	mock.recorder = &MockOrganizationServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockOrganizationService) EXPECT() *MockOrganizationServiceMockRecorder {
	return m.recorder
}

// List mocks base method
func (m *MockOrganizationService) List(arg0 context.Context, arg1 *core.User) ([]*core.Organization, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockOrganizationServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationService)(nil).List), arg0, arg1)
}

// MockSecretService is a mock of SecretService interface
type MockSecretService struct {
	ctrl     *gomock.Controller
	recorder *MockSecretServiceMockRecorder
}

// MockSecretServiceMockRecorder is the mock recorder for MockSecretService
type MockSecretServiceMockRecorder struct {
	mock *MockSecretService
}

// NewMockSecretService creates a new mock instance
func NewMockSecretService(ctrl *gomock.Controller) *MockSecretService {
	mock := &MockSecretService{ctrl: ctrl}
	mock.recorder = &MockSecretServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSecretService) EXPECT() *MockSecretServiceMockRecorder {
	return m.recorder
}

// Find mocks base method
func (m *MockSecretService) Find(arg0 context.Context, arg1 *core.SecretArgs) (*core.Secret, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockSecretServiceMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockSecretService)(nil).Find), arg0, arg1)
}

// MockRegistryService is a mock of RegistryService interface
type MockRegistryService struct {
	ctrl     *gomock.Controller
	recorder *MockRegistryServiceMockRecorder
}

// MockRegistryServiceMockRecorder is the mock recorder for MockRegistryService
type MockRegistryServiceMockRecorder struct {
	mock *MockRegistryService
}

// NewMockRegistryService creates a new mock instance
func NewMockRegistryService(ctrl *gomock.Controller) *MockRegistryService {
	mock := &MockRegistryService{ctrl: ctrl}
	mock.recorder = &MockRegistryServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRegistryService) EXPECT() *MockRegistryServiceMockRecorder {
	return m.recorder
}

// List mocks base method
func (m *MockRegistryService) List(arg0 context.Context, arg1 *core.RegistryArgs) ([]*core.Registry, error) {
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].([]*core.Registry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List
func (mr *MockRegistryServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRegistryService)(nil).List), arg0, arg1)
}

// MockConfigService is a mock of ConfigService interface
type MockConfigService struct {
	ctrl     *gomock.Controller
	recorder *MockConfigServiceMockRecorder
}

// MockConfigServiceMockRecorder is the mock recorder for MockConfigService
type MockConfigServiceMockRecorder struct {
	mock *MockConfigService
}

// NewMockConfigService creates a new mock instance
func NewMockConfigService(ctrl *gomock.Controller) *MockConfigService {
	mock := &MockConfigService{ctrl: ctrl}
	mock.recorder = &MockConfigServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockConfigService) EXPECT() *MockConfigServiceMockRecorder {
	return m.recorder
}

// Find mocks base method
func (m *MockConfigService) Find(arg0 context.Context, arg1 *core.ConfigArgs) (*core.Config, error) {
	ret := m.ctrl.Call(m, "Find", arg0, arg1)
	ret0, _ := ret[0].(*core.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find
func (mr *MockConfigServiceMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockConfigService)(nil).Find), arg0, arg1)
}

// MockTriggerer is a mock of Triggerer interface
type MockTriggerer struct {
	ctrl     *gomock.Controller
	recorder *MockTriggererMockRecorder
}

// MockTriggererMockRecorder is the mock recorder for MockTriggerer
type MockTriggererMockRecorder struct {
	mock *MockTriggerer
}

// NewMockTriggerer creates a new mock instance
func NewMockTriggerer(ctrl *gomock.Controller) *MockTriggerer {
	mock := &MockTriggerer{ctrl: ctrl}
	mock.recorder = &MockTriggererMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockTriggerer) EXPECT() *MockTriggererMockRecorder {
	return m.recorder
}

// Trigger mocks base method
func (m *MockTriggerer) Trigger(arg0 context.Context, arg1 *core.Repository, arg2 *core.Hook) (*core.Build, error) {
	ret := m.ctrl.Call(m, "Trigger", arg0, arg1, arg2)
	ret0, _ := ret[0].(*core.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Trigger indicates an expected call of Trigger
func (mr *MockTriggererMockRecorder) Trigger(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trigger", reflect.TypeOf((*MockTriggerer)(nil).Trigger), arg0, arg1, arg2)
}

// MockSyncer is a mock of Syncer interface
type MockSyncer struct {
	ctrl     *gomock.Controller
	recorder *MockSyncerMockRecorder
}

// MockSyncerMockRecorder is the mock recorder for MockSyncer
type MockSyncerMockRecorder struct {
	mock *MockSyncer
}

// NewMockSyncer creates a new mock instance
func NewMockSyncer(ctrl *gomock.Controller) *MockSyncer {
	mock := &MockSyncer{ctrl: ctrl}
	mock.recorder = &MockSyncerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSyncer) EXPECT() *MockSyncerMockRecorder {
	return m.recorder
}

// Sync mocks base method
func (m *MockSyncer) Sync(arg0 context.Context, arg1 *core.User) (*core.Batch, error) {
	ret := m.ctrl.Call(m, "Sync", arg0, arg1)
	ret0, _ := ret[0].(*core.Batch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sync indicates an expected call of Sync
func (mr *MockSyncerMockRecorder) Sync(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockSyncer)(nil).Sync), arg0, arg1)
}

// MockLogStream is a mock of LogStream interface
type MockLogStream struct {
	ctrl     *gomock.Controller
	recorder *MockLogStreamMockRecorder
}

// MockLogStreamMockRecorder is the mock recorder for MockLogStream
type MockLogStreamMockRecorder struct {
	mock *MockLogStream
}

// NewMockLogStream creates a new mock instance
func NewMockLogStream(ctrl *gomock.Controller) *MockLogStream {
	mock := &MockLogStream{ctrl: ctrl}
	mock.recorder = &MockLogStreamMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockLogStream) EXPECT() *MockLogStreamMockRecorder {
	return m.recorder
}

// Create mocks base method
func (m *MockLogStream) Create(arg0 context.Context, arg1 int64) error {
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockLogStreamMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLogStream)(nil).Create), arg0, arg1)
}

// Delete mocks base method
func (m *MockLogStream) Delete(arg0 context.Context, arg1 int64) error {
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockLogStreamMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLogStream)(nil).Delete), arg0, arg1)
}

// Info mocks base method
func (m *MockLogStream) Info(arg0 context.Context) *core.LogStreamInfo {
	ret := m.ctrl.Call(m, "Info", arg0)
	ret0, _ := ret[0].(*core.LogStreamInfo)
	return ret0
}

// Info indicates an expected call of Info
func (mr *MockLogStreamMockRecorder) Info(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogStream)(nil).Info), arg0)
}

// Tail mocks base method
func (m *MockLogStream) Tail(arg0 context.Context, arg1 int64) (<-chan *core.Line, <-chan error) {
	ret := m.ctrl.Call(m, "Tail", arg0, arg1)
	ret0, _ := ret[0].(<-chan *core.Line)
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// Tail indicates an expected call of Tail
func (mr *MockLogStreamMockRecorder) Tail(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tail", reflect.TypeOf((*MockLogStream)(nil).Tail), arg0, arg1)
}

// Write mocks base method
func (m *MockLogStream) Write(arg0 context.Context, arg1 int64, arg2 *core.Line) error {
	ret := m.ctrl.Call(m, "Write", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write
func (mr *MockLogStreamMockRecorder) Write(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockLogStream)(nil).Write), arg0, arg1, arg2)
}

// MockWebhookSender is a mock of WebhookSender interface
type MockWebhookSender struct {
	ctrl     *gomock.Controller
	recorder *MockWebhookSenderMockRecorder
}

// MockWebhookSenderMockRecorder is the mock recorder for MockWebhookSender
type MockWebhookSenderMockRecorder struct {
	mock *MockWebhookSender
}

// NewMockWebhookSender creates a new mock instance
func NewMockWebhookSender(ctrl *gomock.Controller) *MockWebhookSender {
	mock := &MockWebhookSender{ctrl: ctrl}
	mock.recorder = &MockWebhookSenderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockWebhookSender) EXPECT() *MockWebhookSenderMockRecorder {
	return m.recorder
}

// Send mocks base method
func (m *MockWebhookSender) Send(arg0 context.Context, arg1 *core.WebhookData) error {
	ret := m.ctrl.Call(m, "Send", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send
func (mr *MockWebhookSenderMockRecorder) Send(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockWebhookSender)(nil).Send), arg0, arg1)
}

// MockLicenseService is a mock of LicenseService interface
type MockLicenseService struct {
	ctrl     *gomock.Controller
	recorder *MockLicenseServiceMockRecorder
}

// MockLicenseServiceMockRecorder is the mock recorder for MockLicenseService
type MockLicenseServiceMockRecorder struct {
	mock *MockLicenseService
}

// NewMockLicenseService creates a new mock instance
func NewMockLicenseService(ctrl *gomock.Controller) *MockLicenseService {
	mock := &MockLicenseService{ctrl: ctrl}
	mock.recorder = &MockLicenseServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockLicenseService) EXPECT() *MockLicenseServiceMockRecorder {
	return m.recorder
}

// Exceeded mocks base method
func (m *MockLicenseService) Exceeded(arg0 context.Context) (bool, error) {
	ret := m.ctrl.Call(m, "Exceeded", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exceeded indicates an expected call of Exceeded
func (mr *MockLicenseServiceMockRecorder) Exceeded(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exceeded", reflect.TypeOf((*MockLicenseService)(nil).Exceeded), arg0)
}

// Expired mocks base method
func (m *MockLicenseService) Expired(arg0 context.Context) bool {
	ret := m.ctrl.Call(m, "Expired", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired
func (mr *MockLicenseServiceMockRecorder) Expired(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockLicenseService)(nil).Expired), arg0)
}