pkg.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./interface.go

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

import (
	context "context"
	reflect "reflect"
	time "time"

	interactor "github.com/gitploy-io/gitploy/internal/interactor"
	ent "github.com/gitploy-io/gitploy/model/ent"
	extent "github.com/gitploy-io/gitploy/model/extent"
	gomock "github.com/golang/mock/gomock"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// Activate mocks base method.
func (m *MockStore) Activate(ctx context.Context, r *ent.Repo) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Activate", ctx, r)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Activate indicates an expected call of Activate.
func (mr *MockStoreMockRecorder) Activate(ctx, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Activate", reflect.TypeOf((*MockStore)(nil).Activate), ctx, r)
}

// CheckNotificationRecordOfEvent mocks base method.
func (m *MockStore) CheckNotificationRecordOfEvent(ctx context.Context, e *ent.Event) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckNotificationRecordOfEvent", ctx, e)
	ret0, _ := ret[0].(bool)
	return ret0
}

// CheckNotificationRecordOfEvent indicates an expected call of CheckNotificationRecordOfEvent.
func (mr *MockStoreMockRecorder) CheckNotificationRecordOfEvent(ctx, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckNotificationRecordOfEvent", reflect.TypeOf((*MockStore)(nil).CheckNotificationRecordOfEvent), ctx, e)
}

// CountActiveRepos mocks base method.
func (m *MockStore) CountActiveRepos(ctx context.Context) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountActiveRepos", ctx)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountActiveRepos indicates an expected call of CountActiveRepos.
func (mr *MockStoreMockRecorder) CountActiveRepos(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountActiveRepos", reflect.TypeOf((*MockStore)(nil).CountActiveRepos), ctx)
}

// CountDeployments mocks base method.
func (m *MockStore) CountDeployments(ctx context.Context) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountDeployments", ctx)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountDeployments indicates an expected call of CountDeployments.
func (mr *MockStoreMockRecorder) CountDeployments(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountDeployments", reflect.TypeOf((*MockStore)(nil).CountDeployments), ctx)
}

// CountRepos mocks base method.
func (m *MockStore) CountRepos(ctx context.Context) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountRepos", ctx)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountRepos indicates an expected call of CountRepos.
func (mr *MockStoreMockRecorder) CountRepos(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountRepos", reflect.TypeOf((*MockStore)(nil).CountRepos), ctx)
}

// CountUsers mocks base method.
func (m *MockStore) CountUsers(arg0 context.Context) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountUsers", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountUsers indicates an expected call of CountUsers.
func (mr *MockStoreMockRecorder) CountUsers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountUsers", reflect.TypeOf((*MockStore)(nil).CountUsers), arg0)
}

// CreateChatUser mocks base method.
func (m *MockStore) CreateChatUser(ctx context.Context, cu *ent.ChatUser) (*ent.ChatUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChatUser", ctx, cu)
	ret0, _ := ret[0].(*ent.ChatUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateChatUser indicates an expected call of CreateChatUser.
func (mr *MockStoreMockRecorder) CreateChatUser(ctx, cu interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChatUser", reflect.TypeOf((*MockStore)(nil).CreateChatUser), ctx, cu)
}

// CreateDeployment mocks base method.
func (m *MockStore) CreateDeployment(ctx context.Context, d *ent.Deployment) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeployment", ctx, d)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDeployment indicates an expected call of CreateDeployment.
func (mr *MockStoreMockRecorder) CreateDeployment(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeployment", reflect.TypeOf((*MockStore)(nil).CreateDeployment), ctx, d)
}

// CreateDeploymentStatistics mocks base method.
func (m *MockStore) CreateDeploymentStatistics(ctx context.Context, s *ent.DeploymentStatistics) (*ent.DeploymentStatistics, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeploymentStatistics", ctx, s)
	ret0, _ := ret[0].(*ent.DeploymentStatistics)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDeploymentStatistics indicates an expected call of CreateDeploymentStatistics.
func (mr *MockStoreMockRecorder) CreateDeploymentStatistics(ctx, s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeploymentStatistics", reflect.TypeOf((*MockStore)(nil).CreateDeploymentStatistics), ctx, s)
}

// CreateEntDeploymentStatus mocks base method.
func (m *MockStore) CreateEntDeploymentStatus(ctx context.Context, s *ent.DeploymentStatus) (*ent.DeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEntDeploymentStatus", ctx, s)
	ret0, _ := ret[0].(*ent.DeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateEntDeploymentStatus indicates an expected call of CreateEntDeploymentStatus.
func (mr *MockStoreMockRecorder) CreateEntDeploymentStatus(ctx, s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEntDeploymentStatus", reflect.TypeOf((*MockStore)(nil).CreateEntDeploymentStatus), ctx, s)
}

// CreateEvent mocks base method.
func (m *MockStore) CreateEvent(ctx context.Context, e *ent.Event) (*ent.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEvent", ctx, e)
	ret0, _ := ret[0].(*ent.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateEvent indicates an expected call of CreateEvent.
func (mr *MockStoreMockRecorder) CreateEvent(ctx, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEvent", reflect.TypeOf((*MockStore)(nil).CreateEvent), ctx, e)
}

// CreateLock mocks base method.
func (m *MockStore) CreateLock(ctx context.Context, l *ent.Lock) (*ent.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLock", ctx, l)
	ret0, _ := ret[0].(*ent.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLock indicates an expected call of CreateLock.
func (mr *MockStoreMockRecorder) CreateLock(ctx, l interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLock", reflect.TypeOf((*MockStore)(nil).CreateLock), ctx, l)
}

// CreatePerm mocks base method.
func (m *MockStore) CreatePerm(ctx context.Context, p *ent.Perm) (*ent.Perm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePerm", ctx, p)
	ret0, _ := ret[0].(*ent.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePerm indicates an expected call of CreatePerm.
func (mr *MockStoreMockRecorder) CreatePerm(ctx, p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePerm", reflect.TypeOf((*MockStore)(nil).CreatePerm), ctx, p)
}

// CreateReview mocks base method.
func (m *MockStore) CreateReview(ctx context.Context, rv *ent.Review) (*ent.Review, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReview", ctx, rv)
	ret0, _ := ret[0].(*ent.Review)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReview indicates an expected call of CreateReview.
func (mr *MockStoreMockRecorder) CreateReview(ctx, rv interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReview", reflect.TypeOf((*MockStore)(nil).CreateReview), ctx, rv)
}

// CreateUser mocks base method.
func (m *MockStore) CreateUser(ctx context.Context, u *ent.User) (*ent.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUser", ctx, u)
	ret0, _ := ret[0].(*ent.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUser indicates an expected call of CreateUser.
func (mr *MockStoreMockRecorder) CreateUser(ctx, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockStore)(nil).CreateUser), ctx, u)
}

// Deactivate mocks base method.
func (m *MockStore) Deactivate(ctx context.Context, r *ent.Repo) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Deactivate", ctx, r)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Deactivate indicates an expected call of Deactivate.
func (mr *MockStoreMockRecorder) Deactivate(ctx, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deactivate", reflect.TypeOf((*MockStore)(nil).Deactivate), ctx, r)
}

// DeleteChatUser mocks base method.
func (m *MockStore) DeleteChatUser(ctx context.Context, cu *ent.ChatUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatUser", ctx, cu)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChatUser indicates an expected call of DeleteChatUser.
func (mr *MockStoreMockRecorder) DeleteChatUser(ctx, cu interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatUser", reflect.TypeOf((*MockStore)(nil).DeleteChatUser), ctx, cu)
}

// DeleteLock mocks base method.
func (m *MockStore) DeleteLock(ctx context.Context, l *ent.Lock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLock", ctx, l)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLock indicates an expected call of DeleteLock.
func (mr *MockStoreMockRecorder) DeleteLock(ctx, l interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLock", reflect.TypeOf((*MockStore)(nil).DeleteLock), ctx, l)
}

// DeletePerm mocks base method.
func (m *MockStore) DeletePerm(ctx context.Context, p *ent.Perm) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePerm", ctx, p)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePerm indicates an expected call of DeletePerm.
func (mr *MockStoreMockRecorder) DeletePerm(ctx, p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePerm", reflect.TypeOf((*MockStore)(nil).DeletePerm), ctx, p)
}

// DeletePermsOfUserLessThanSyncedAt mocks base method.
func (m *MockStore) DeletePermsOfUserLessThanSyncedAt(ctx context.Context, u *ent.User, t time.Time) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePermsOfUserLessThanSyncedAt", ctx, u, t)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePermsOfUserLessThanSyncedAt indicates an expected call of DeletePermsOfUserLessThanSyncedAt.
func (mr *MockStoreMockRecorder) DeletePermsOfUserLessThanSyncedAt(ctx, u, t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePermsOfUserLessThanSyncedAt", reflect.TypeOf((*MockStore)(nil).DeletePermsOfUserLessThanSyncedAt), ctx, u, t)
}

// DeleteUser mocks base method.
func (m *MockStore) DeleteUser(ctx context.Context, u *ent.User) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUser", ctx, u)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUser indicates an expected call of DeleteUser.
func (mr *MockStoreMockRecorder) DeleteUser(ctx, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockStore)(nil).DeleteUser), ctx, u)
}

// FindChatUserByID mocks base method.
func (m *MockStore) FindChatUserByID(ctx context.Context, id string) (*ent.ChatUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindChatUserByID", ctx, id)
	ret0, _ := ret[0].(*ent.ChatUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindChatUserByID indicates an expected call of FindChatUserByID.
func (mr *MockStoreMockRecorder) FindChatUserByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindChatUserByID", reflect.TypeOf((*MockStore)(nil).FindChatUserByID), ctx, id)
}

// FindDeploymentByID mocks base method.
func (m *MockStore) FindDeploymentByID(ctx context.Context, id int) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDeploymentByID", ctx, id)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindDeploymentByID indicates an expected call of FindDeploymentByID.
func (mr *MockStoreMockRecorder) FindDeploymentByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeploymentByID", reflect.TypeOf((*MockStore)(nil).FindDeploymentByID), ctx, id)
}

// FindDeploymentByUID mocks base method.
func (m *MockStore) FindDeploymentByUID(ctx context.Context, uid int64) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDeploymentByUID", ctx, uid)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindDeploymentByUID indicates an expected call of FindDeploymentByUID.
func (mr *MockStoreMockRecorder) FindDeploymentByUID(ctx, uid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeploymentByUID", reflect.TypeOf((*MockStore)(nil).FindDeploymentByUID), ctx, uid)
}

// FindDeploymentOfRepoByNumber mocks base method.
func (m *MockStore) FindDeploymentOfRepoByNumber(ctx context.Context, r *ent.Repo, number int) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDeploymentOfRepoByNumber", ctx, r, number)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindDeploymentOfRepoByNumber indicates an expected call of FindDeploymentOfRepoByNumber.
func (mr *MockStoreMockRecorder) FindDeploymentOfRepoByNumber(ctx, r, number interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeploymentOfRepoByNumber", reflect.TypeOf((*MockStore)(nil).FindDeploymentOfRepoByNumber), ctx, r, number)
}

// FindDeploymentStatisticsOfRepoByEnv mocks base method.
func (m *MockStore) FindDeploymentStatisticsOfRepoByEnv(ctx context.Context, r *ent.Repo, env string) (*ent.DeploymentStatistics, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDeploymentStatisticsOfRepoByEnv", ctx, r, env)
	ret0, _ := ret[0].(*ent.DeploymentStatistics)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindDeploymentStatisticsOfRepoByEnv indicates an expected call of FindDeploymentStatisticsOfRepoByEnv.
func (mr *MockStoreMockRecorder) FindDeploymentStatisticsOfRepoByEnv(ctx, r, env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeploymentStatisticsOfRepoByEnv", reflect.TypeOf((*MockStore)(nil).FindDeploymentStatisticsOfRepoByEnv), ctx, r, env)
}

// FindDeploymentStatusByID mocks base method.
func (m *MockStore) FindDeploymentStatusByID(ctx context.Context, id int) (*ent.DeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDeploymentStatusByID", ctx, id)
	ret0, _ := ret[0].(*ent.DeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindDeploymentStatusByID indicates an expected call of FindDeploymentStatusByID.
func (mr *MockStoreMockRecorder) FindDeploymentStatusByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeploymentStatusByID", reflect.TypeOf((*MockStore)(nil).FindDeploymentStatusByID), ctx, id)
}

// FindLockByID mocks base method.
func (m *MockStore) FindLockByID(ctx context.Context, id int) (*ent.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindLockByID", ctx, id)
	ret0, _ := ret[0].(*ent.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindLockByID indicates an expected call of FindLockByID.
func (mr *MockStoreMockRecorder) FindLockByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLockByID", reflect.TypeOf((*MockStore)(nil).FindLockByID), ctx, id)
}

// FindLockOfRepoByEnv mocks base method.
func (m *MockStore) FindLockOfRepoByEnv(ctx context.Context, r *ent.Repo, env string) (*ent.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindLockOfRepoByEnv", ctx, r, env)
	ret0, _ := ret[0].(*ent.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindLockOfRepoByEnv indicates an expected call of FindLockOfRepoByEnv.
func (mr *MockStoreMockRecorder) FindLockOfRepoByEnv(ctx, r, env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLockOfRepoByEnv", reflect.TypeOf((*MockStore)(nil).FindLockOfRepoByEnv), ctx, r, env)
}

// FindPermOfRepo mocks base method.
func (m *MockStore) FindPermOfRepo(ctx context.Context, r *ent.Repo, u *ent.User) (*ent.Perm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPermOfRepo", ctx, r, u)
	ret0, _ := ret[0].(*ent.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindPermOfRepo indicates an expected call of FindPermOfRepo.
func (mr *MockStoreMockRecorder) FindPermOfRepo(ctx, r, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPermOfRepo", reflect.TypeOf((*MockStore)(nil).FindPermOfRepo), ctx, r, u)
}

// FindPrevRunningDeployment mocks base method.
func (m *MockStore) FindPrevRunningDeployment(ctx context.Context, d *ent.Deployment) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPrevRunningDeployment", ctx, d)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindPrevRunningDeployment indicates an expected call of FindPrevRunningDeployment.
func (mr *MockStoreMockRecorder) FindPrevRunningDeployment(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPrevRunningDeployment", reflect.TypeOf((*MockStore)(nil).FindPrevRunningDeployment), ctx, d)
}

// FindPrevSuccessDeployment mocks base method.
func (m *MockStore) FindPrevSuccessDeployment(ctx context.Context, d *ent.Deployment) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPrevSuccessDeployment", ctx, d)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindPrevSuccessDeployment indicates an expected call of FindPrevSuccessDeployment.
func (mr *MockStoreMockRecorder) FindPrevSuccessDeployment(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPrevSuccessDeployment", reflect.TypeOf((*MockStore)(nil).FindPrevSuccessDeployment), ctx, d)
}

// FindRepoByID mocks base method.
func (m *MockStore) FindRepoByID(ctx context.Context, id int64) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindRepoByID", ctx, id)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRepoByID indicates an expected call of FindRepoByID.
func (mr *MockStoreMockRecorder) FindRepoByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRepoByID", reflect.TypeOf((*MockStore)(nil).FindRepoByID), ctx, id)
}

// FindRepoOfUserByID mocks base method.
func (m *MockStore) FindRepoOfUserByID(ctx context.Context, u *ent.User, id int64) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindRepoOfUserByID", ctx, u, id)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRepoOfUserByID indicates an expected call of FindRepoOfUserByID.
func (mr *MockStoreMockRecorder) FindRepoOfUserByID(ctx, u, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRepoOfUserByID", reflect.TypeOf((*MockStore)(nil).FindRepoOfUserByID), ctx, u, id)
}

// FindRepoOfUserByNamespaceName mocks base method.
func (m *MockStore) FindRepoOfUserByNamespaceName(ctx context.Context, u *ent.User, opt *interactor.FindRepoOfUserByNamespaceNameOptions) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindRepoOfUserByNamespaceName", ctx, u, opt)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindRepoOfUserByNamespaceName indicates an expected call of FindRepoOfUserByNamespaceName.
func (mr *MockStoreMockRecorder) FindRepoOfUserByNamespaceName(ctx, u, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRepoOfUserByNamespaceName", reflect.TypeOf((*MockStore)(nil).FindRepoOfUserByNamespaceName), ctx, u, opt)
}

// FindReviewByID mocks base method.
func (m *MockStore) FindReviewByID(ctx context.Context, id int) (*ent.Review, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindReviewByID", ctx, id)
	ret0, _ := ret[0].(*ent.Review)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindReviewByID indicates an expected call of FindReviewByID.
func (mr *MockStoreMockRecorder) FindReviewByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindReviewByID", reflect.TypeOf((*MockStore)(nil).FindReviewByID), ctx, id)
}

// FindReviewOfUser mocks base method.
func (m *MockStore) FindReviewOfUser(ctx context.Context, u *ent.User, d *ent.Deployment) (*ent.Review, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindReviewOfUser", ctx, u, d)
	ret0, _ := ret[0].(*ent.Review)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindReviewOfUser indicates an expected call of FindReviewOfUser.
func (mr *MockStoreMockRecorder) FindReviewOfUser(ctx, u, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindReviewOfUser", reflect.TypeOf((*MockStore)(nil).FindReviewOfUser), ctx, u, d)
}

// FindUserByHash mocks base method.
func (m *MockStore) FindUserByHash(ctx context.Context, hash string) (*ent.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindUserByHash", ctx, hash)
	ret0, _ := ret[0].(*ent.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindUserByHash indicates an expected call of FindUserByHash.
func (mr *MockStoreMockRecorder) FindUserByHash(ctx, hash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindUserByHash", reflect.TypeOf((*MockStore)(nil).FindUserByHash), ctx, hash)
}

// FindUserByID mocks base method.
func (m *MockStore) FindUserByID(ctx context.Context, id int64) (*ent.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindUserByID", ctx, id)
	ret0, _ := ret[0].(*ent.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindUserByID indicates an expected call of FindUserByID.
func (mr *MockStoreMockRecorder) FindUserByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindUserByID", reflect.TypeOf((*MockStore)(nil).FindUserByID), ctx, id)
}

// FindUserByLogin mocks base method.
func (m *MockStore) FindUserByLogin(ctx context.Context, login string) (*ent.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindUserByLogin", ctx, login)
	ret0, _ := ret[0].(*ent.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindUserByLogin indicates an expected call of FindUserByLogin.
func (mr *MockStoreMockRecorder) FindUserByLogin(ctx, login interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindUserByLogin", reflect.TypeOf((*MockStore)(nil).FindUserByLogin), ctx, login)
}

// GetNextDeploymentNumberOfRepo mocks base method.
func (m *MockStore) GetNextDeploymentNumberOfRepo(ctx context.Context, r *ent.Repo) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNextDeploymentNumberOfRepo", ctx, r)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNextDeploymentNumberOfRepo indicates an expected call of GetNextDeploymentNumberOfRepo.
func (mr *MockStoreMockRecorder) GetNextDeploymentNumberOfRepo(ctx, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNextDeploymentNumberOfRepo", reflect.TypeOf((*MockStore)(nil).GetNextDeploymentNumberOfRepo), ctx, r)
}

// HasLockOfRepoForEnv mocks base method.
func (m *MockStore) HasLockOfRepoForEnv(ctx context.Context, r *ent.Repo, env string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasLockOfRepoForEnv", ctx, r, env)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasLockOfRepoForEnv indicates an expected call of HasLockOfRepoForEnv.
func (mr *MockStoreMockRecorder) HasLockOfRepoForEnv(ctx, r, env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasLockOfRepoForEnv", reflect.TypeOf((*MockStore)(nil).HasLockOfRepoForEnv), ctx, r, env)
}

// ListAllDeploymentStatistics mocks base method.
func (m *MockStore) ListAllDeploymentStatistics(ctx context.Context) ([]*ent.DeploymentStatistics, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllDeploymentStatistics", ctx)
	ret0, _ := ret[0].([]*ent.DeploymentStatistics)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllDeploymentStatistics indicates an expected call of ListAllDeploymentStatistics.
func (mr *MockStoreMockRecorder) ListAllDeploymentStatistics(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllDeploymentStatistics", reflect.TypeOf((*MockStore)(nil).ListAllDeploymentStatistics), ctx)
}

// ListDeploymentStatisticsGreaterThanTime mocks base method.
func (m *MockStore) ListDeploymentStatisticsGreaterThanTime(ctx context.Context, updated time.Time) ([]*ent.DeploymentStatistics, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeploymentStatisticsGreaterThanTime", ctx, updated)
	ret0, _ := ret[0].([]*ent.DeploymentStatistics)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeploymentStatisticsGreaterThanTime indicates an expected call of ListDeploymentStatisticsGreaterThanTime.
func (mr *MockStoreMockRecorder) ListDeploymentStatisticsGreaterThanTime(ctx, updated interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeploymentStatisticsGreaterThanTime", reflect.TypeOf((*MockStore)(nil).ListDeploymentStatisticsGreaterThanTime), ctx, updated)
}

// ListDeploymentStatuses mocks base method.
func (m *MockStore) ListDeploymentStatuses(ctx context.Context, d *ent.Deployment) ([]*ent.DeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeploymentStatuses", ctx, d)
	ret0, _ := ret[0].([]*ent.DeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeploymentStatuses indicates an expected call of ListDeploymentStatuses.
func (mr *MockStoreMockRecorder) ListDeploymentStatuses(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeploymentStatuses", reflect.TypeOf((*MockStore)(nil).ListDeploymentStatuses), ctx, d)
}

// ListDeploymentsOfRepo mocks base method.
func (m *MockStore) ListDeploymentsOfRepo(ctx context.Context, r *ent.Repo, opt *interactor.ListDeploymentsOfRepoOptions) ([]*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeploymentsOfRepo", ctx, r, opt)
	ret0, _ := ret[0].([]*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeploymentsOfRepo indicates an expected call of ListDeploymentsOfRepo.
func (mr *MockStoreMockRecorder) ListDeploymentsOfRepo(ctx, r, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeploymentsOfRepo", reflect.TypeOf((*MockStore)(nil).ListDeploymentsOfRepo), ctx, r, opt)
}

// ListEventsGreaterThanTime mocks base method.
func (m *MockStore) ListEventsGreaterThanTime(ctx context.Context, t time.Time) ([]*ent.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEventsGreaterThanTime", ctx, t)
	ret0, _ := ret[0].([]*ent.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEventsGreaterThanTime indicates an expected call of ListEventsGreaterThanTime.
func (mr *MockStoreMockRecorder) ListEventsGreaterThanTime(ctx, t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventsGreaterThanTime", reflect.TypeOf((*MockStore)(nil).ListEventsGreaterThanTime), ctx, t)
}

// ListExpiredLocksLessThanTime mocks base method.
func (m *MockStore) ListExpiredLocksLessThanTime(ctx context.Context, t time.Time) ([]*ent.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExpiredLocksLessThanTime", ctx, t)
	ret0, _ := ret[0].([]*ent.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExpiredLocksLessThanTime indicates an expected call of ListExpiredLocksLessThanTime.
func (mr *MockStoreMockRecorder) ListExpiredLocksLessThanTime(ctx, t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExpiredLocksLessThanTime", reflect.TypeOf((*MockStore)(nil).ListExpiredLocksLessThanTime), ctx, t)
}

// ListInactiveDeploymentsLessThanTime mocks base method.
func (m *MockStore) ListInactiveDeploymentsLessThanTime(ctx context.Context, opt *interactor.ListInactiveDeploymentsLessThanTimeOptions) ([]*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInactiveDeploymentsLessThanTime", ctx, opt)
	ret0, _ := ret[0].([]*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInactiveDeploymentsLessThanTime indicates an expected call of ListInactiveDeploymentsLessThanTime.
func (mr *MockStoreMockRecorder) ListInactiveDeploymentsLessThanTime(ctx, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInactiveDeploymentsLessThanTime", reflect.TypeOf((*MockStore)(nil).ListInactiveDeploymentsLessThanTime), ctx, opt)
}

// ListLocksOfRepo mocks base method.
func (m *MockStore) ListLocksOfRepo(ctx context.Context, r *ent.Repo) ([]*ent.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLocksOfRepo", ctx, r)
	ret0, _ := ret[0].([]*ent.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLocksOfRepo indicates an expected call of ListLocksOfRepo.
func (mr *MockStoreMockRecorder) ListLocksOfRepo(ctx, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocksOfRepo", reflect.TypeOf((*MockStore)(nil).ListLocksOfRepo), ctx, r)
}

// ListPerms mocks base method.
func (m *MockStore) ListPerms(ctx context.Context, opt *interactor.ListOptions) ([]*ent.Perm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPerms", ctx, opt)
	ret0, _ := ret[0].([]*ent.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPerms indicates an expected call of ListPerms.
func (mr *MockStoreMockRecorder) ListPerms(ctx, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPerms", reflect.TypeOf((*MockStore)(nil).ListPerms), ctx, opt)
}

// ListPermsOfRepo mocks base method.
func (m *MockStore) ListPermsOfRepo(ctx context.Context, r *ent.Repo, opt *interactor.ListPermsOfRepoOptions) ([]*ent.Perm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPermsOfRepo", ctx, r, opt)
	ret0, _ := ret[0].([]*ent.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPermsOfRepo indicates an expected call of ListPermsOfRepo.
func (mr *MockStoreMockRecorder) ListPermsOfRepo(ctx, r, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPermsOfRepo", reflect.TypeOf((*MockStore)(nil).ListPermsOfRepo), ctx, r, opt)
}

// ListReposOfUser mocks base method.
func (m *MockStore) ListReposOfUser(ctx context.Context, u *ent.User, opt *interactor.ListReposOfUserOptions) ([]*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReposOfUser", ctx, u, opt)
	ret0, _ := ret[0].([]*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReposOfUser indicates an expected call of ListReposOfUser.
func (mr *MockStoreMockRecorder) ListReposOfUser(ctx, u, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReposOfUser", reflect.TypeOf((*MockStore)(nil).ListReposOfUser), ctx, u, opt)
}

// ListReviews mocks base method.
func (m *MockStore) ListReviews(ctx context.Context, d *ent.Deployment) ([]*ent.Review, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReviews", ctx, d)
	ret0, _ := ret[0].([]*ent.Review)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReviews indicates an expected call of ListReviews.
func (mr *MockStoreMockRecorder) ListReviews(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReviews", reflect.TypeOf((*MockStore)(nil).ListReviews), ctx, d)
}

// SearchDeploymentsOfUser mocks base method.
func (m *MockStore) SearchDeploymentsOfUser(ctx context.Context, u *ent.User, opt *interactor.SearchDeploymentsOfUserOptions) ([]*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDeploymentsOfUser", ctx, u, opt)
	ret0, _ := ret[0].([]*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchDeploymentsOfUser indicates an expected call of SearchDeploymentsOfUser.
func (mr *MockStoreMockRecorder) SearchDeploymentsOfUser(ctx, u, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchDeploymentsOfUser", reflect.TypeOf((*MockStore)(nil).SearchDeploymentsOfUser), ctx, u, opt)
}

// SearchReviews mocks base method.
func (m *MockStore) SearchReviews(ctx context.Context, u *ent.User) ([]*ent.Review, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchReviews", ctx, u)
	ret0, _ := ret[0].([]*ent.Review)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchReviews indicates an expected call of SearchReviews.
func (mr *MockStoreMockRecorder) SearchReviews(ctx, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchReviews", reflect.TypeOf((*MockStore)(nil).SearchReviews), ctx, u)
}

// SearchUsers mocks base method.
func (m *MockStore) SearchUsers(ctx context.Context, opts *interactor.SearchUsersOptions) ([]*ent.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchUsers", ctx, opts)
	ret0, _ := ret[0].([]*ent.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchUsers indicates an expected call of SearchUsers.
func (mr *MockStoreMockRecorder) SearchUsers(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchUsers", reflect.TypeOf((*MockStore)(nil).SearchUsers), ctx, opts)
}

// SyncRepo mocks base method.
func (m *MockStore) SyncRepo(ctx context.Context, r *extent.RemoteRepo) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncRepo", ctx, r)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncRepo indicates an expected call of SyncRepo.
func (mr *MockStoreMockRecorder) SyncRepo(ctx, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncRepo", reflect.TypeOf((*MockStore)(nil).SyncRepo), ctx, r)
}

// UpdateChatUser mocks base method.
func (m *MockStore) UpdateChatUser(ctx context.Context, cu *ent.ChatUser) (*ent.ChatUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatUser", ctx, cu)
	ret0, _ := ret[0].(*ent.ChatUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatUser indicates an expected call of UpdateChatUser.
func (mr *MockStoreMockRecorder) UpdateChatUser(ctx, cu interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatUser", reflect.TypeOf((*MockStore)(nil).UpdateChatUser), ctx, cu)
}

// UpdateDeployment mocks base method.
func (m *MockStore) UpdateDeployment(ctx context.Context, d *ent.Deployment) (*ent.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDeployment", ctx, d)
	ret0, _ := ret[0].(*ent.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDeployment indicates an expected call of UpdateDeployment.
func (mr *MockStoreMockRecorder) UpdateDeployment(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeployment", reflect.TypeOf((*MockStore)(nil).UpdateDeployment), ctx, d)
}

// UpdateDeploymentStatistics mocks base method.
func (m *MockStore) UpdateDeploymentStatistics(ctx context.Context, s *ent.DeploymentStatistics) (*ent.DeploymentStatistics, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDeploymentStatistics", ctx, s)
	ret0, _ := ret[0].(*ent.DeploymentStatistics)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDeploymentStatistics indicates an expected call of UpdateDeploymentStatistics.
func (mr *MockStoreMockRecorder) UpdateDeploymentStatistics(ctx, s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeploymentStatistics", reflect.TypeOf((*MockStore)(nil).UpdateDeploymentStatistics), ctx, s)
}

// UpdateLock mocks base method.
func (m *MockStore) UpdateLock(ctx context.Context, l *ent.Lock) (*ent.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLock", ctx, l)
	ret0, _ := ret[0].(*ent.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLock indicates an expected call of UpdateLock.
func (mr *MockStoreMockRecorder) UpdateLock(ctx, l interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLock", reflect.TypeOf((*MockStore)(nil).UpdateLock), ctx, l)
}

// UpdatePerm mocks base method.
func (m *MockStore) UpdatePerm(ctx context.Context, p *ent.Perm) (*ent.Perm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePerm", ctx, p)
	ret0, _ := ret[0].(*ent.Perm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePerm indicates an expected call of UpdatePerm.
func (mr *MockStoreMockRecorder) UpdatePerm(ctx, p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePerm", reflect.TypeOf((*MockStore)(nil).UpdatePerm), ctx, p)
}

// UpdateRepo mocks base method.
func (m *MockStore) UpdateRepo(ctx context.Context, r *ent.Repo) (*ent.Repo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRepo", ctx, r)
	ret0, _ := ret[0].(*ent.Repo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRepo indicates an expected call of UpdateRepo.
func (mr *MockStoreMockRecorder) UpdateRepo(ctx, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRepo", reflect.TypeOf((*MockStore)(nil).UpdateRepo), ctx, r)
}

// UpdateReview mocks base method.
func (m *MockStore) UpdateReview(ctx context.Context, rv *ent.Review) (*ent.Review, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateReview", ctx, rv)
	ret0, _ := ret[0].(*ent.Review)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateReview indicates an expected call of UpdateReview.
func (mr *MockStoreMockRecorder) UpdateReview(ctx, rv interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateReview", reflect.TypeOf((*MockStore)(nil).UpdateReview), ctx, rv)
}

// UpdateUser mocks base method.
func (m *MockStore) UpdateUser(ctx context.Context, u *ent.User) (*ent.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUser", ctx, u)
	ret0, _ := ret[0].(*ent.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockStoreMockRecorder) UpdateUser(ctx, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockStore)(nil).UpdateUser), ctx, u)
}

// MockDeploymentStatusStore is a mock of DeploymentStatusStore interface.
type MockDeploymentStatusStore struct {
	ctrl     *gomock.Controller
	recorder *MockDeploymentStatusStoreMockRecorder
}

// MockDeploymentStatusStoreMockRecorder is the mock recorder for MockDeploymentStatusStore.
type MockDeploymentStatusStoreMockRecorder struct {
	mock *MockDeploymentStatusStore
}

// NewMockDeploymentStatusStore creates a new mock instance.
func NewMockDeploymentStatusStore(ctrl *gomock.Controller) *MockDeploymentStatusStore {
	mock := &MockDeploymentStatusStore{ctrl: ctrl}
	mock.recorder = &MockDeploymentStatusStoreMockRecorder{mock}
	return mock
}

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

// CreateEntDeploymentStatus mocks base method.
func (m *MockDeploymentStatusStore) CreateEntDeploymentStatus(ctx context.Context, s *ent.DeploymentStatus) (*ent.DeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEntDeploymentStatus", ctx, s)
	ret0, _ := ret[0].(*ent.DeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateEntDeploymentStatus indicates an expected call of CreateEntDeploymentStatus.
func (mr *MockDeploymentStatusStoreMockRecorder) CreateEntDeploymentStatus(ctx, s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEntDeploymentStatus", reflect.TypeOf((*MockDeploymentStatusStore)(nil).CreateEntDeploymentStatus), ctx, s)
}

// FindDeploymentStatusByID mocks base method.
func (m *MockDeploymentStatusStore) FindDeploymentStatusByID(ctx context.Context, id int) (*ent.DeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDeploymentStatusByID", ctx, id)
	ret0, _ := ret[0].(*ent.DeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindDeploymentStatusByID indicates an expected call of FindDeploymentStatusByID.
func (mr *MockDeploymentStatusStoreMockRecorder) FindDeploymentStatusByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeploymentStatusByID", reflect.TypeOf((*MockDeploymentStatusStore)(nil).FindDeploymentStatusByID), ctx, id)
}

// ListDeploymentStatuses mocks base method.
func (m *MockDeploymentStatusStore) ListDeploymentStatuses(ctx context.Context, d *ent.Deployment) ([]*ent.DeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeploymentStatuses", ctx, d)
	ret0, _ := ret[0].([]*ent.DeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeploymentStatuses indicates an expected call of ListDeploymentStatuses.
func (mr *MockDeploymentStatusStoreMockRecorder) ListDeploymentStatuses(ctx, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeploymentStatuses", reflect.TypeOf((*MockDeploymentStatusStore)(nil).ListDeploymentStatuses), ctx, d)
}

// MockSCM is a mock of SCM interface.
type MockSCM struct {
	ctrl     *gomock.Controller
	recorder *MockSCMMockRecorder
}

// MockSCMMockRecorder is the mock recorder for MockSCM.
type MockSCMMockRecorder struct {
	mock *MockSCM
}

// NewMockSCM creates a new mock instance.
func NewMockSCM(ctrl *gomock.Controller) *MockSCM {
	mock := &MockSCM{ctrl: ctrl}
	mock.recorder = &MockSCMMockRecorder{mock}
	return mock
}

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

// CancelDeployment mocks base method.
func (m *MockSCM) CancelDeployment(ctx context.Context, u *ent.User, r *ent.Repo, d *ent.Deployment, s *ent.DeploymentStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelDeployment", ctx, u, r, d, s)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelDeployment indicates an expected call of CancelDeployment.
func (mr *MockSCMMockRecorder) CancelDeployment(ctx, u, r, d, s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelDeployment", reflect.TypeOf((*MockSCM)(nil).CancelDeployment), ctx, u, r, d, s)
}

// CompareCommits mocks base method.
func (m *MockSCM) CompareCommits(ctx context.Context, u *ent.User, r *ent.Repo, base, head string, opt *interactor.ListOptions) ([]*extent.Commit, []*extent.CommitFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareCommits", ctx, u, r, base, head, opt)
	ret0, _ := ret[0].([]*extent.Commit)
	ret1, _ := ret[1].([]*extent.CommitFile)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CompareCommits indicates an expected call of CompareCommits.
func (mr *MockSCMMockRecorder) CompareCommits(ctx, u, r, base, head, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareCommits", reflect.TypeOf((*MockSCM)(nil).CompareCommits), ctx, u, r, base, head, opt)
}

// CreateRemoteDeployment mocks base method.
func (m *MockSCM) CreateRemoteDeployment(ctx context.Context, u *ent.User, r *ent.Repo, d *ent.Deployment, e *extent.Env) (*extent.RemoteDeployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRemoteDeployment", ctx, u, r, d, e)
	ret0, _ := ret[0].(*extent.RemoteDeployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRemoteDeployment indicates an expected call of CreateRemoteDeployment.
func (mr *MockSCMMockRecorder) CreateRemoteDeployment(ctx, u, r, d, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRemoteDeployment", reflect.TypeOf((*MockSCM)(nil).CreateRemoteDeployment), ctx, u, r, d, e)
}

// CreateRemoteDeploymentStatus mocks base method.
func (m *MockSCM) CreateRemoteDeploymentStatus(ctx context.Context, u *ent.User, r *ent.Repo, d *ent.Deployment, ds *extent.RemoteDeploymentStatus) (*extent.RemoteDeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRemoteDeploymentStatus", ctx, u, r, d, ds)
	ret0, _ := ret[0].(*extent.RemoteDeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRemoteDeploymentStatus indicates an expected call of CreateRemoteDeploymentStatus.
func (mr *MockSCMMockRecorder) CreateRemoteDeploymentStatus(ctx, u, r, d, ds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRemoteDeploymentStatus", reflect.TypeOf((*MockSCM)(nil).CreateRemoteDeploymentStatus), ctx, u, r, d, ds)
}

// CreateWebhook mocks base method.
func (m *MockSCM) CreateWebhook(ctx context.Context, u *ent.User, r *ent.Repo, c *extent.WebhookConfig) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWebhook", ctx, u, r, c)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWebhook indicates an expected call of CreateWebhook.
func (mr *MockSCMMockRecorder) CreateWebhook(ctx, u, r, c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWebhook", reflect.TypeOf((*MockSCM)(nil).CreateWebhook), ctx, u, r, c)
}

// DeleteWebhook mocks base method.
func (m *MockSCM) DeleteWebhook(ctx context.Context, u *ent.User, r *ent.Repo, id int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebhook", ctx, u, r, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWebhook indicates an expected call of DeleteWebhook.
func (mr *MockSCMMockRecorder) DeleteWebhook(ctx, u, r, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWebhook", reflect.TypeOf((*MockSCM)(nil).DeleteWebhook), ctx, u, r, id)
}

// GetBranch mocks base method.
func (m *MockSCM) GetBranch(ctx context.Context, u *ent.User, r *ent.Repo, branch string) (*extent.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", ctx, u, r, branch)
	ret0, _ := ret[0].(*extent.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranch indicates an expected call of GetBranch.
func (mr *MockSCMMockRecorder) GetBranch(ctx, u, r, branch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockSCM)(nil).GetBranch), ctx, u, r, branch)
}

// GetCommit mocks base method.
func (m *MockSCM) GetCommit(ctx context.Context, u *ent.User, r *ent.Repo, sha string) (*extent.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", ctx, u, r, sha)
	ret0, _ := ret[0].(*extent.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockSCMMockRecorder) GetCommit(ctx, u, r, sha interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockSCM)(nil).GetCommit), ctx, u, r, sha)
}

// GetConfig mocks base method.
func (m *MockSCM) GetConfig(ctx context.Context, u *ent.User, r *ent.Repo) (*extent.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig", ctx, u, r)
	ret0, _ := ret[0].(*extent.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfig indicates an expected call of GetConfig.
func (mr *MockSCMMockRecorder) GetConfig(ctx, u, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockSCM)(nil).GetConfig), ctx, u, r)
}

// GetConfigRedirectURL mocks base method.
func (m *MockSCM) GetConfigRedirectURL(ctx context.Context, u *ent.User, r *ent.Repo) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigRedirectURL", ctx, u, r)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigRedirectURL indicates an expected call of GetConfigRedirectURL.
func (mr *MockSCMMockRecorder) GetConfigRedirectURL(ctx, u, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigRedirectURL", reflect.TypeOf((*MockSCM)(nil).GetConfigRedirectURL), ctx, u, r)
}

// GetNewConfigRedirectURL mocks base method.
func (m *MockSCM) GetNewConfigRedirectURL(ctx context.Context, u *ent.User, r *ent.Repo) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNewConfigRedirectURL", ctx, u, r)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNewConfigRedirectURL indicates an expected call of GetNewConfigRedirectURL.
func (mr *MockSCMMockRecorder) GetNewConfigRedirectURL(ctx, u, r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNewConfigRedirectURL", reflect.TypeOf((*MockSCM)(nil).GetNewConfigRedirectURL), ctx, u, r)
}

// GetRateLimit mocks base method.
func (m *MockSCM) GetRateLimit(ctx context.Context, u *ent.User) (*extent.RateLimit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRateLimit", ctx, u)
	ret0, _ := ret[0].(*extent.RateLimit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRateLimit indicates an expected call of GetRateLimit.
func (mr *MockSCMMockRecorder) GetRateLimit(ctx, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimit", reflect.TypeOf((*MockSCM)(nil).GetRateLimit), ctx, u)
}

// GetRemoteUserByToken mocks base method.
func (m *MockSCM) GetRemoteUserByToken(ctx context.Context, token string) (*extent.RemoteUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRemoteUserByToken", ctx, token)
	ret0, _ := ret[0].(*extent.RemoteUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRemoteUserByToken indicates an expected call of GetRemoteUserByToken.
func (mr *MockSCMMockRecorder) GetRemoteUserByToken(ctx, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteUserByToken", reflect.TypeOf((*MockSCM)(nil).GetRemoteUserByToken), ctx, token)
}

// GetTag mocks base method.
func (m *MockSCM) GetTag(ctx context.Context, u *ent.User, r *ent.Repo, tag string) (*extent.Tag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTag", ctx, u, r, tag)
	ret0, _ := ret[0].(*extent.Tag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTag indicates an expected call of GetTag.
func (mr *MockSCMMockRecorder) GetTag(ctx, u, r, tag interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockSCM)(nil).GetTag), ctx, u, r, tag)
}

// ListBranches mocks base method.
func (m *MockSCM) ListBranches(ctx context.Context, u *ent.User, r *ent.Repo, opt *interactor.ListOptions) ([]*extent.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx, u, r, opt)
	ret0, _ := ret[0].([]*extent.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockSCMMockRecorder) ListBranches(ctx, u, r, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockSCM)(nil).ListBranches), ctx, u, r, opt)
}

// ListCommitStatuses mocks base method.
func (m *MockSCM) ListCommitStatuses(ctx context.Context, u *ent.User, r *ent.Repo, sha string) ([]*extent.Status, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommitStatuses", ctx, u, r, sha)
	ret0, _ := ret[0].([]*extent.Status)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommitStatuses indicates an expected call of ListCommitStatuses.
func (mr *MockSCMMockRecorder) ListCommitStatuses(ctx, u, r, sha interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommitStatuses", reflect.TypeOf((*MockSCM)(nil).ListCommitStatuses), ctx, u, r, sha)
}

// ListCommits mocks base method.
func (m *MockSCM) ListCommits(ctx context.Context, u *ent.User, r *ent.Repo, branch string, opt *interactor.ListOptions) ([]*extent.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommits", ctx, u, r, branch, opt)
	ret0, _ := ret[0].([]*extent.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockSCMMockRecorder) ListCommits(ctx, u, r, branch, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockSCM)(nil).ListCommits), ctx, u, r, branch, opt)
}

// ListRemoteOrgsByToken mocks base method.
func (m *MockSCM) ListRemoteOrgsByToken(ctx context.Context, token string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRemoteOrgsByToken", ctx, token)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRemoteOrgsByToken indicates an expected call of ListRemoteOrgsByToken.
func (mr *MockSCMMockRecorder) ListRemoteOrgsByToken(ctx, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRemoteOrgsByToken", reflect.TypeOf((*MockSCM)(nil).ListRemoteOrgsByToken), ctx, token)
}

// ListRemoteRepos mocks base method.
func (m *MockSCM) ListRemoteRepos(ctx context.Context, u *ent.User) ([]*extent.RemoteRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRemoteRepos", ctx, u)
	ret0, _ := ret[0].([]*extent.RemoteRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRemoteRepos indicates an expected call of ListRemoteRepos.
func (mr *MockSCMMockRecorder) ListRemoteRepos(ctx, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRemoteRepos", reflect.TypeOf((*MockSCM)(nil).ListRemoteRepos), ctx, u)
}

// ListTags mocks base method.
func (m *MockSCM) ListTags(ctx context.Context, u *ent.User, r *ent.Repo, opt *interactor.ListOptions) ([]*extent.Tag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", ctx, u, r, opt)
	ret0, _ := ret[0].([]*extent.Tag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTags indicates an expected call of ListTags.
func (mr *MockSCMMockRecorder) ListTags(ctx, u, r, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockSCM)(nil).ListTags), ctx, u, r, opt)
}

// MockDeploymentStatusSCM is a mock of DeploymentStatusSCM interface.
type MockDeploymentStatusSCM struct {
	ctrl     *gomock.Controller
	recorder *MockDeploymentStatusSCMMockRecorder
}

// MockDeploymentStatusSCMMockRecorder is the mock recorder for MockDeploymentStatusSCM.
type MockDeploymentStatusSCMMockRecorder struct {
	mock *MockDeploymentStatusSCM
}

// NewMockDeploymentStatusSCM creates a new mock instance.
func NewMockDeploymentStatusSCM(ctrl *gomock.Controller) *MockDeploymentStatusSCM {
	mock := &MockDeploymentStatusSCM{ctrl: ctrl}
	mock.recorder = &MockDeploymentStatusSCMMockRecorder{mock}
	return mock
}

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

// CreateRemoteDeploymentStatus mocks base method.
func (m *MockDeploymentStatusSCM) CreateRemoteDeploymentStatus(ctx context.Context, u *ent.User, r *ent.Repo, d *ent.Deployment, ds *extent.RemoteDeploymentStatus) (*extent.RemoteDeploymentStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRemoteDeploymentStatus", ctx, u, r, d, ds)
	ret0, _ := ret[0].(*extent.RemoteDeploymentStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRemoteDeploymentStatus indicates an expected call of CreateRemoteDeploymentStatus.
func (mr *MockDeploymentStatusSCMMockRecorder) CreateRemoteDeploymentStatus(ctx, u, r, d, ds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRemoteDeploymentStatus", reflect.TypeOf((*MockDeploymentStatusSCM)(nil).CreateRemoteDeploymentStatus), ctx, u, r, d, ds)
}

// MockCommitSCM is a mock of CommitSCM interface.
type MockCommitSCM struct {
	ctrl     *gomock.Controller
	recorder *MockCommitSCMMockRecorder
}

// MockCommitSCMMockRecorder is the mock recorder for MockCommitSCM.
type MockCommitSCMMockRecorder struct {
	mock *MockCommitSCM
}

// NewMockCommitSCM creates a new mock instance.
func NewMockCommitSCM(ctrl *gomock.Controller) *MockCommitSCM {
	mock := &MockCommitSCM{ctrl: ctrl}
	mock.recorder = &MockCommitSCMMockRecorder{mock}
	return mock
}

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

// CompareCommits mocks base method.
func (m *MockCommitSCM) CompareCommits(ctx context.Context, u *ent.User, r *ent.Repo, base, head string, opt *interactor.ListOptions) ([]*extent.Commit, []*extent.CommitFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareCommits", ctx, u, r, base, head, opt)
	ret0, _ := ret[0].([]*extent.Commit)
	ret1, _ := ret[1].([]*extent.CommitFile)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CompareCommits indicates an expected call of CompareCommits.
func (mr *MockCommitSCMMockRecorder) CompareCommits(ctx, u, r, base, head, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareCommits", reflect.TypeOf((*MockCommitSCM)(nil).CompareCommits), ctx, u, r, base, head, opt)
}

// GetCommit mocks base method.
func (m *MockCommitSCM) GetCommit(ctx context.Context, u *ent.User, r *ent.Repo, sha string) (*extent.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", ctx, u, r, sha)
	ret0, _ := ret[0].(*extent.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockCommitSCMMockRecorder) GetCommit(ctx, u, r, sha interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockCommitSCM)(nil).GetCommit), ctx, u, r, sha)
}

// ListCommitStatuses mocks base method.
func (m *MockCommitSCM) ListCommitStatuses(ctx context.Context, u *ent.User, r *ent.Repo, sha string) ([]*extent.Status, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommitStatuses", ctx, u, r, sha)
	ret0, _ := ret[0].([]*extent.Status)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommitStatuses indicates an expected call of ListCommitStatuses.
func (mr *MockCommitSCMMockRecorder) ListCommitStatuses(ctx, u, r, sha interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommitStatuses", reflect.TypeOf((*MockCommitSCM)(nil).ListCommitStatuses), ctx, u, r, sha)
}

// ListCommits mocks base method.
func (m *MockCommitSCM) ListCommits(ctx context.Context, u *ent.User, r *ent.Repo, branch string, opt *interactor.ListOptions) ([]*extent.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommits", ctx, u, r, branch, opt)
	ret0, _ := ret[0].([]*extent.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockCommitSCMMockRecorder) ListCommits(ctx, u, r, branch, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockCommitSCM)(nil).ListCommits), ctx, u, r, branch, opt)
}

// MockBranchSCM is a mock of BranchSCM interface.
type MockBranchSCM struct {
	ctrl     *gomock.Controller
	recorder *MockBranchSCMMockRecorder
}

// MockBranchSCMMockRecorder is the mock recorder for MockBranchSCM.
type MockBranchSCMMockRecorder struct {
	mock *MockBranchSCM
}

// NewMockBranchSCM creates a new mock instance.
func NewMockBranchSCM(ctrl *gomock.Controller) *MockBranchSCM {
	mock := &MockBranchSCM{ctrl: ctrl}
	mock.recorder = &MockBranchSCMMockRecorder{mock}
	return mock
}

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

// GetBranch mocks base method.
func (m *MockBranchSCM) GetBranch(ctx context.Context, u *ent.User, r *ent.Repo, branch string) (*extent.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", ctx, u, r, branch)
	ret0, _ := ret[0].(*extent.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranch indicates an expected call of GetBranch.
func (mr *MockBranchSCMMockRecorder) GetBranch(ctx, u, r, branch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockBranchSCM)(nil).GetBranch), ctx, u, r, branch)
}

// ListBranches mocks base method.
func (m *MockBranchSCM) ListBranches(ctx context.Context, u *ent.User, r *ent.Repo, opt *interactor.ListOptions) ([]*extent.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx, u, r, opt)
	ret0, _ := ret[0].([]*extent.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockBranchSCMMockRecorder) ListBranches(ctx, u, r, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockBranchSCM)(nil).ListBranches), ctx, u, r, opt)
}

// MockTagSCM is a mock of TagSCM interface.
type MockTagSCM struct {
	ctrl     *gomock.Controller
	recorder *MockTagSCMMockRecorder
}

// MockTagSCMMockRecorder is the mock recorder for MockTagSCM.
type MockTagSCMMockRecorder struct {
	mock *MockTagSCM
}

// NewMockTagSCM creates a new mock instance.
func NewMockTagSCM(ctrl *gomock.Controller) *MockTagSCM {
	mock := &MockTagSCM{ctrl: ctrl}
	mock.recorder = &MockTagSCMMockRecorder{mock}
	return mock
}

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

// GetTag mocks base method.
func (m *MockTagSCM) GetTag(ctx context.Context, u *ent.User, r *ent.Repo, tag string) (*extent.Tag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTag", ctx, u, r, tag)
	ret0, _ := ret[0].(*extent.Tag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTag indicates an expected call of GetTag.
func (mr *MockTagSCMMockRecorder) GetTag(ctx, u, r, tag interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockTagSCM)(nil).GetTag), ctx, u, r, tag)
}

// ListTags mocks base method.
func (m *MockTagSCM) ListTags(ctx context.Context, u *ent.User, r *ent.Repo, opt *interactor.ListOptions) ([]*extent.Tag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", ctx, u, r, opt)
	ret0, _ := ret[0].([]*extent.Tag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTags indicates an expected call of ListTags.
func (mr *MockTagSCMMockRecorder) ListTags(ctx, u, r, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockTagSCM)(nil).ListTags), ctx, u, r, opt)
}