// Code generated by MockGen. DO NOT EDIT.
// Source: gitea_utils.go
//
// Generated by this command:
//
//	mockgen -source=gitea_utils.go -destination=mock/gitea_utils.go -typed
//

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

import (
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"
	common "src.opensuse.org/autogits/common"
	models "src.opensuse.org/autogits/common/gitea-generated/models"
)

// MockGiteaTimelineFetcher is a mock of GiteaTimelineFetcher interface.
type MockGiteaTimelineFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaTimelineFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaTimelineFetcherMockRecorder is the mock recorder for MockGiteaTimelineFetcher.
type MockGiteaTimelineFetcherMockRecorder struct {
	mock *MockGiteaTimelineFetcher
}

// NewMockGiteaTimelineFetcher creates a new mock instance.
func NewMockGiteaTimelineFetcher(ctrl *gomock.Controller) *MockGiteaTimelineFetcher {
	mock := &MockGiteaTimelineFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaTimelineFetcherMockRecorder{mock}
	return mock
}

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

// GetTimeline mocks base method.
func (m *MockGiteaTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
	ret0, _ := ret[0].([]*models.TimelineComment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimeline indicates an expected call of GetTimeline.
func (mr *MockGiteaTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaTimelineFetcherGetTimelineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaTimelineFetcher)(nil).GetTimeline), org, repo, idx)
	return &MockGiteaTimelineFetcherGetTimelineCall{Call: call}
}

// MockGiteaTimelineFetcherGetTimelineCall wrap *gomock.Call
type MockGiteaTimelineFetcherGetTimelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaTimelineFetcherGetTimelineCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaTimelineFetcherGetTimelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaTimelineFetcherGetTimelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaComment is a mock of GiteaComment interface.
type MockGiteaComment struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaCommentMockRecorder
	isgomock struct{}
}

// MockGiteaCommentMockRecorder is the mock recorder for MockGiteaComment.
type MockGiteaCommentMockRecorder struct {
	mock *MockGiteaComment
}

// NewMockGiteaComment creates a new mock instance.
func NewMockGiteaComment(ctrl *gomock.Controller) *MockGiteaComment {
	mock := &MockGiteaComment{ctrl: ctrl}
	mock.recorder = &MockGiteaCommentMockRecorder{mock}
	return mock
}

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

// AddComment mocks base method.
func (m *MockGiteaComment) AddComment(pr *models.PullRequest, comment string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddComment", pr, comment)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddComment indicates an expected call of AddComment.
func (mr *MockGiteaCommentMockRecorder) AddComment(pr, comment any) *MockGiteaCommentAddCommentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddComment", reflect.TypeOf((*MockGiteaComment)(nil).AddComment), pr, comment)
	return &MockGiteaCommentAddCommentCall{Call: call}
}

// MockGiteaCommentAddCommentCall wrap *gomock.Call
type MockGiteaCommentAddCommentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCommentAddCommentCall) Return(arg0 error) *MockGiteaCommentAddCommentCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCommentAddCommentCall) Do(f func(*models.PullRequest, string) error) *MockGiteaCommentAddCommentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCommentAddCommentCall) DoAndReturn(f func(*models.PullRequest, string) error) *MockGiteaCommentAddCommentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaSetRepoOptions is a mock of GiteaSetRepoOptions interface.
type MockGiteaSetRepoOptions struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaSetRepoOptionsMockRecorder
	isgomock struct{}
}

// MockGiteaSetRepoOptionsMockRecorder is the mock recorder for MockGiteaSetRepoOptions.
type MockGiteaSetRepoOptionsMockRecorder struct {
	mock *MockGiteaSetRepoOptions
}

// NewMockGiteaSetRepoOptions creates a new mock instance.
func NewMockGiteaSetRepoOptions(ctrl *gomock.Controller) *MockGiteaSetRepoOptions {
	mock := &MockGiteaSetRepoOptions{ctrl: ctrl}
	mock.recorder = &MockGiteaSetRepoOptionsMockRecorder{mock}
	return mock
}

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

// SetRepoOptions mocks base method.
func (m *MockGiteaSetRepoOptions) SetRepoOptions(owner, repo string, manual_merge bool) (*models.Repository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRepoOptions", owner, repo, manual_merge)
	ret0, _ := ret[0].(*models.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetRepoOptions indicates an expected call of SetRepoOptions.
func (mr *MockGiteaSetRepoOptionsMockRecorder) SetRepoOptions(owner, repo, manual_merge any) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepoOptions", reflect.TypeOf((*MockGiteaSetRepoOptions)(nil).SetRepoOptions), owner, repo, manual_merge)
	return &MockGiteaSetRepoOptionsSetRepoOptionsCall{Call: call}
}

// MockGiteaSetRepoOptionsSetRepoOptionsCall wrap *gomock.Call
type MockGiteaSetRepoOptionsSetRepoOptionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) Do(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) DoAndReturn(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaMaintainershipReader is a mock of GiteaMaintainershipReader interface.
type MockGiteaMaintainershipReader struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaMaintainershipReaderMockRecorder
	isgomock struct{}
}

// MockGiteaMaintainershipReaderMockRecorder is the mock recorder for MockGiteaMaintainershipReader.
type MockGiteaMaintainershipReaderMockRecorder struct {
	mock *MockGiteaMaintainershipReader
}

// NewMockGiteaMaintainershipReader creates a new mock instance.
func NewMockGiteaMaintainershipReader(ctrl *gomock.Controller) *MockGiteaMaintainershipReader {
	mock := &MockGiteaMaintainershipReader{ctrl: ctrl}
	mock.recorder = &MockGiteaMaintainershipReaderMockRecorder{mock}
	return mock
}

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

// FetchMaintainershipDirFile mocks base method.
func (m *MockGiteaMaintainershipReader) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile.
func (mr *MockGiteaMaintainershipReaderMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGiteaMaintainershipReader)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg)
	return &MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall{Call: call}
}

// MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall wrap *gomock.Call
type MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FetchMaintainershipFile mocks base method.
func (m *MockGiteaMaintainershipReader) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile.
func (mr *MockGiteaMaintainershipReaderMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGiteaMaintainershipReader)(nil).FetchMaintainershipFile), org, prjGit, branch)
	return &MockGiteaMaintainershipReaderFetchMaintainershipFileCall{Call: call}
}

// MockGiteaMaintainershipReaderFetchMaintainershipFileCall wrap *gomock.Call
type MockGiteaMaintainershipReaderFetchMaintainershipFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaPRFetcher is a mock of GiteaPRFetcher interface.
type MockGiteaPRFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaPRFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaPRFetcherMockRecorder is the mock recorder for MockGiteaPRFetcher.
type MockGiteaPRFetcherMockRecorder struct {
	mock *MockGiteaPRFetcher
}

// NewMockGiteaPRFetcher creates a new mock instance.
func NewMockGiteaPRFetcher(ctrl *gomock.Controller) *MockGiteaPRFetcher {
	mock := &MockGiteaPRFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaPRFetcherMockRecorder{mock}
	return mock
}

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

// GetPullRequest mocks base method.
func (m *MockGiteaPRFetcher) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequest", org, project, num)
	ret0, _ := ret[0].(*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequest indicates an expected call of GetPullRequest.
func (mr *MockGiteaPRFetcherMockRecorder) GetPullRequest(org, project, num any) *MockGiteaPRFetcherGetPullRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGiteaPRFetcher)(nil).GetPullRequest), org, project, num)
	return &MockGiteaPRFetcherGetPullRequestCall{Call: call}
}

// MockGiteaPRFetcherGetPullRequestCall wrap *gomock.Call
type MockGiteaPRFetcherGetPullRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRFetcherGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRFetcherGetPullRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRFetcherGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRFetcherGetPullRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRFetcherGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRFetcherGetPullRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaPRUpdater is a mock of GiteaPRUpdater interface.
type MockGiteaPRUpdater struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaPRUpdaterMockRecorder
	isgomock struct{}
}

// MockGiteaPRUpdaterMockRecorder is the mock recorder for MockGiteaPRUpdater.
type MockGiteaPRUpdaterMockRecorder struct {
	mock *MockGiteaPRUpdater
}

// NewMockGiteaPRUpdater creates a new mock instance.
func NewMockGiteaPRUpdater(ctrl *gomock.Controller) *MockGiteaPRUpdater {
	mock := &MockGiteaPRUpdater{ctrl: ctrl}
	mock.recorder = &MockGiteaPRUpdaterMockRecorder{mock}
	return mock
}

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

// UpdatePullRequest mocks base method.
func (m *MockGiteaPRUpdater) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequest", org, repo, num, options)
	ret0, _ := ret[0].(*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePullRequest indicates an expected call of UpdatePullRequest.
func (mr *MockGiteaPRUpdaterMockRecorder) UpdatePullRequest(org, repo, num, options any) *MockGiteaPRUpdaterUpdatePullRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGiteaPRUpdater)(nil).UpdatePullRequest), org, repo, num, options)
	return &MockGiteaPRUpdaterUpdatePullRequestCall{Call: call}
}

// MockGiteaPRUpdaterUpdatePullRequestCall wrap *gomock.Call
type MockGiteaPRUpdaterUpdatePullRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRUpdaterUpdatePullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRUpdaterUpdatePullRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRUpdaterUpdatePullRequestCall) Do(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaPRUpdaterUpdatePullRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRUpdaterUpdatePullRequestCall) DoAndReturn(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaPRUpdaterUpdatePullRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaPRTimelineFetcher is a mock of GiteaPRTimelineFetcher interface.
type MockGiteaPRTimelineFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaPRTimelineFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaPRTimelineFetcherMockRecorder is the mock recorder for MockGiteaPRTimelineFetcher.
type MockGiteaPRTimelineFetcherMockRecorder struct {
	mock *MockGiteaPRTimelineFetcher
}

// NewMockGiteaPRTimelineFetcher creates a new mock instance.
func NewMockGiteaPRTimelineFetcher(ctrl *gomock.Controller) *MockGiteaPRTimelineFetcher {
	mock := &MockGiteaPRTimelineFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaPRTimelineFetcherMockRecorder{mock}
	return mock
}

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

// GetPullRequest mocks base method.
func (m *MockGiteaPRTimelineFetcher) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequest", org, project, num)
	ret0, _ := ret[0].(*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequest indicates an expected call of GetPullRequest.
func (mr *MockGiteaPRTimelineFetcherMockRecorder) GetPullRequest(org, project, num any) *MockGiteaPRTimelineFetcherGetPullRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGiteaPRTimelineFetcher)(nil).GetPullRequest), org, project, num)
	return &MockGiteaPRTimelineFetcherGetPullRequestCall{Call: call}
}

// MockGiteaPRTimelineFetcherGetPullRequestCall wrap *gomock.Call
type MockGiteaPRTimelineFetcherGetPullRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRTimelineFetcherGetPullRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRTimelineFetcherGetPullRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRTimelineFetcherGetPullRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTimeline mocks base method.
func (m *MockGiteaPRTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
	ret0, _ := ret[0].([]*models.TimelineComment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimeline indicates an expected call of GetTimeline.
func (mr *MockGiteaPRTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaPRTimelineFetcherGetTimelineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaPRTimelineFetcher)(nil).GetTimeline), org, repo, idx)
	return &MockGiteaPRTimelineFetcherGetTimelineCall{Call: call}
}

// MockGiteaPRTimelineFetcherGetTimelineCall wrap *gomock.Call
type MockGiteaPRTimelineFetcherGetTimelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaPRTimelineFetcherGetTimelineCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRTimelineFetcherGetTimelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRTimelineFetcherGetTimelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaCommitFetcher is a mock of GiteaCommitFetcher interface.
type MockGiteaCommitFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaCommitFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaCommitFetcherMockRecorder is the mock recorder for MockGiteaCommitFetcher.
type MockGiteaCommitFetcherMockRecorder struct {
	mock *MockGiteaCommitFetcher
}

// NewMockGiteaCommitFetcher creates a new mock instance.
func NewMockGiteaCommitFetcher(ctrl *gomock.Controller) *MockGiteaCommitFetcher {
	mock := &MockGiteaCommitFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaCommitFetcherMockRecorder{mock}
	return mock
}

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

// GetCommit mocks base method.
func (m *MockGiteaCommitFetcher) GetCommit(org, repo, sha string) (*models.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", org, repo, sha)
	ret0, _ := ret[0].(*models.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockGiteaCommitFetcherMockRecorder) GetCommit(org, repo, sha any) *MockGiteaCommitFetcherGetCommitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGiteaCommitFetcher)(nil).GetCommit), org, repo, sha)
	return &MockGiteaCommitFetcherGetCommitCall{Call: call}
}

// MockGiteaCommitFetcherGetCommitCall wrap *gomock.Call
type MockGiteaCommitFetcherGetCommitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCommitFetcherGetCommitCall) Return(arg0 *models.Commit, arg1 error) *MockGiteaCommitFetcherGetCommitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCommitFetcherGetCommitCall) Do(f func(string, string, string) (*models.Commit, error)) *MockGiteaCommitFetcherGetCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCommitFetcherGetCommitCall) DoAndReturn(f func(string, string, string) (*models.Commit, error)) *MockGiteaCommitFetcherGetCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaReviewFetcher is a mock of GiteaReviewFetcher interface.
type MockGiteaReviewFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaReviewFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaReviewFetcherMockRecorder is the mock recorder for MockGiteaReviewFetcher.
type MockGiteaReviewFetcherMockRecorder struct {
	mock *MockGiteaReviewFetcher
}

// NewMockGiteaReviewFetcher creates a new mock instance.
func NewMockGiteaReviewFetcher(ctrl *gomock.Controller) *MockGiteaReviewFetcher {
	mock := &MockGiteaReviewFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaReviewFetcherMockRecorder{mock}
	return mock
}

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

// GetPullRequestReviews mocks base method.
func (m *MockGiteaReviewFetcher) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
func (mr *MockGiteaReviewFetcherMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewFetcher)(nil).GetPullRequestReviews), org, project, PRnum)
	return &MockGiteaReviewFetcherGetPullRequestReviewsCall{Call: call}
}

// MockGiteaReviewFetcherGetPullRequestReviewsCall wrap *gomock.Call
type MockGiteaReviewFetcherGetPullRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaCommentFetcher is a mock of GiteaCommentFetcher interface.
type MockGiteaCommentFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaCommentFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaCommentFetcherMockRecorder is the mock recorder for MockGiteaCommentFetcher.
type MockGiteaCommentFetcherMockRecorder struct {
	mock *MockGiteaCommentFetcher
}

// NewMockGiteaCommentFetcher creates a new mock instance.
func NewMockGiteaCommentFetcher(ctrl *gomock.Controller) *MockGiteaCommentFetcher {
	mock := &MockGiteaCommentFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaCommentFetcherMockRecorder{mock}
	return mock
}

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

// GetIssueComments mocks base method.
func (m *MockGiteaCommentFetcher) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
	ret0, _ := ret[0].([]*models.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIssueComments indicates an expected call of GetIssueComments.
func (mr *MockGiteaCommentFetcherMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaCommentFetcherGetIssueCommentsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaCommentFetcher)(nil).GetIssueComments), org, project, issueNo)
	return &MockGiteaCommentFetcherGetIssueCommentsCall{Call: call}
}

// MockGiteaCommentFetcherGetIssueCommentsCall wrap *gomock.Call
type MockGiteaCommentFetcherGetIssueCommentsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCommentFetcherGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaCommentFetcherGetIssueCommentsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCommentFetcherGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaCommentFetcherGetIssueCommentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCommentFetcherGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaCommentFetcherGetIssueCommentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaReviewTimelineFetcher is a mock of GiteaReviewTimelineFetcher interface.
type MockGiteaReviewTimelineFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaReviewTimelineFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaReviewTimelineFetcherMockRecorder is the mock recorder for MockGiteaReviewTimelineFetcher.
type MockGiteaReviewTimelineFetcherMockRecorder struct {
	mock *MockGiteaReviewTimelineFetcher
}

// NewMockGiteaReviewTimelineFetcher creates a new mock instance.
func NewMockGiteaReviewTimelineFetcher(ctrl *gomock.Controller) *MockGiteaReviewTimelineFetcher {
	mock := &MockGiteaReviewTimelineFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaReviewTimelineFetcherMockRecorder{mock}
	return mock
}

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

// GetPullRequestReviews mocks base method.
func (m *MockGiteaReviewTimelineFetcher) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
func (mr *MockGiteaReviewTimelineFetcherMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewTimelineFetcher)(nil).GetPullRequestReviews), org, project, PRnum)
	return &MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall{Call: call}
}

// MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall wrap *gomock.Call
type MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTimeline mocks base method.
func (m *MockGiteaReviewTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
	ret0, _ := ret[0].([]*models.TimelineComment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimeline indicates an expected call of GetTimeline.
func (mr *MockGiteaReviewTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaReviewTimelineFetcherGetTimelineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaReviewTimelineFetcher)(nil).GetTimeline), org, repo, idx)
	return &MockGiteaReviewTimelineFetcherGetTimelineCall{Call: call}
}

// MockGiteaReviewTimelineFetcherGetTimelineCall wrap *gomock.Call
type MockGiteaReviewTimelineFetcherGetTimelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaReviewTimelineFetcherGetTimelineCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewTimelineFetcherGetTimelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewTimelineFetcherGetTimelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaPRChecker is a mock of GiteaPRChecker interface.
type MockGiteaPRChecker struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaPRCheckerMockRecorder
	isgomock struct{}
}

// MockGiteaPRCheckerMockRecorder is the mock recorder for MockGiteaPRChecker.
type MockGiteaPRCheckerMockRecorder struct {
	mock *MockGiteaPRChecker
}

// NewMockGiteaPRChecker creates a new mock instance.
func NewMockGiteaPRChecker(ctrl *gomock.Controller) *MockGiteaPRChecker {
	mock := &MockGiteaPRChecker{ctrl: ctrl}
	mock.recorder = &MockGiteaPRCheckerMockRecorder{mock}
	return mock
}

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

// FetchMaintainershipDirFile mocks base method.
func (m *MockGiteaPRChecker) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile.
func (mr *MockGiteaPRCheckerMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGiteaPRChecker)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg)
	return &MockGiteaPRCheckerFetchMaintainershipDirFileCall{Call: call}
}

// MockGiteaPRCheckerFetchMaintainershipDirFileCall wrap *gomock.Call
type MockGiteaPRCheckerFetchMaintainershipDirFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FetchMaintainershipFile mocks base method.
func (m *MockGiteaPRChecker) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile.
func (mr *MockGiteaPRCheckerMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaPRCheckerFetchMaintainershipFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGiteaPRChecker)(nil).FetchMaintainershipFile), org, prjGit, branch)
	return &MockGiteaPRCheckerFetchMaintainershipFileCall{Call: call}
}

// MockGiteaPRCheckerFetchMaintainershipFileCall wrap *gomock.Call
type MockGiteaPRCheckerFetchMaintainershipFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaPRCheckerFetchMaintainershipFileCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetIssueComments mocks base method.
func (m *MockGiteaPRChecker) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
	ret0, _ := ret[0].([]*models.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIssueComments indicates an expected call of GetIssueComments.
func (mr *MockGiteaPRCheckerMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaPRCheckerGetIssueCommentsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetIssueComments), org, project, issueNo)
	return &MockGiteaPRCheckerGetIssueCommentsCall{Call: call}
}

// MockGiteaPRCheckerGetIssueCommentsCall wrap *gomock.Call
type MockGiteaPRCheckerGetIssueCommentsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRCheckerGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaPRCheckerGetIssueCommentsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRCheckerGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaPRCheckerGetIssueCommentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRCheckerGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaPRCheckerGetIssueCommentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetPullRequestReviews mocks base method.
func (m *MockGiteaPRChecker) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
func (mr *MockGiteaPRCheckerMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaPRCheckerGetPullRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetPullRequestReviews), org, project, PRnum)
	return &MockGiteaPRCheckerGetPullRequestReviewsCall{Call: call}
}

// MockGiteaPRCheckerGetPullRequestReviewsCall wrap *gomock.Call
type MockGiteaPRCheckerGetPullRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaPRCheckerGetPullRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaPRCheckerGetPullRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaPRCheckerGetPullRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTimeline mocks base method.
func (m *MockGiteaPRChecker) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
	ret0, _ := ret[0].([]*models.TimelineComment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimeline indicates an expected call of GetTimeline.
func (mr *MockGiteaPRCheckerMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaPRCheckerGetTimelineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetTimeline), org, repo, idx)
	return &MockGiteaPRCheckerGetTimelineCall{Call: call}
}

// MockGiteaPRCheckerGetTimelineCall wrap *gomock.Call
type MockGiteaPRCheckerGetTimelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaPRCheckerGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaPRCheckerGetTimelineCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaPRCheckerGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRCheckerGetTimelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaPRCheckerGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRCheckerGetTimelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaReviewFetcherAndRequester is a mock of GiteaReviewFetcherAndRequester interface.
type MockGiteaReviewFetcherAndRequester struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaReviewFetcherAndRequesterMockRecorder
	isgomock struct{}
}

// MockGiteaReviewFetcherAndRequesterMockRecorder is the mock recorder for MockGiteaReviewFetcherAndRequester.
type MockGiteaReviewFetcherAndRequesterMockRecorder struct {
	mock *MockGiteaReviewFetcherAndRequester
}

// NewMockGiteaReviewFetcherAndRequester creates a new mock instance.
func NewMockGiteaReviewFetcherAndRequester(ctrl *gomock.Controller) *MockGiteaReviewFetcherAndRequester {
	mock := &MockGiteaReviewFetcherAndRequester{ctrl: ctrl}
	mock.recorder = &MockGiteaReviewFetcherAndRequesterMockRecorder{mock}
	return mock
}

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

// GetIssueComments mocks base method.
func (m *MockGiteaReviewFetcherAndRequester) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
	ret0, _ := ret[0].([]*models.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIssueComments indicates an expected call of GetIssueComments.
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetIssueComments), org, project, issueNo)
	return &MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall{Call: call}
}

// MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall wrap *gomock.Call
type MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetPullRequestReviews mocks base method.
func (m *MockGiteaReviewFetcherAndRequester) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetPullRequestReviews), org, project, PRnum)
	return &MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall{Call: call}
}

// MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall wrap *gomock.Call
type MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTimeline mocks base method.
func (m *MockGiteaReviewFetcherAndRequester) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
	ret0, _ := ret[0].([]*models.TimelineComment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimeline indicates an expected call of GetTimeline.
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetTimeline), org, repo, idx)
	return &MockGiteaReviewFetcherAndRequesterGetTimelineCall{Call: call}
}

// MockGiteaReviewFetcherAndRequesterGetTimelineCall wrap *gomock.Call
type MockGiteaReviewFetcherAndRequesterGetTimelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RequestReviews mocks base method.
func (m *MockGiteaReviewFetcherAndRequester) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	varargs := []any{pr}
	for _, a := range reviewer {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestReviews", varargs...)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RequestReviews indicates an expected call of RequestReviews.
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pr}, reviewer...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).RequestReviews), varargs...)
	return &MockGiteaReviewFetcherAndRequesterRequestReviewsCall{Call: call}
}

// MockGiteaReviewFetcherAndRequesterRequestReviewsCall wrap *gomock.Call
type MockGiteaReviewFetcherAndRequesterRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaReviewRequester is a mock of GiteaReviewRequester interface.
type MockGiteaReviewRequester struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaReviewRequesterMockRecorder
	isgomock struct{}
}

// MockGiteaReviewRequesterMockRecorder is the mock recorder for MockGiteaReviewRequester.
type MockGiteaReviewRequesterMockRecorder struct {
	mock *MockGiteaReviewRequester
}

// NewMockGiteaReviewRequester creates a new mock instance.
func NewMockGiteaReviewRequester(ctrl *gomock.Controller) *MockGiteaReviewRequester {
	mock := &MockGiteaReviewRequester{ctrl: ctrl}
	mock.recorder = &MockGiteaReviewRequesterMockRecorder{mock}
	return mock
}

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

// RequestReviews mocks base method.
func (m *MockGiteaReviewRequester) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	varargs := []any{pr}
	for _, a := range reviewer {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestReviews", varargs...)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RequestReviews indicates an expected call of RequestReviews.
func (mr *MockGiteaReviewRequesterMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaReviewRequesterRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pr}, reviewer...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGiteaReviewRequester)(nil).RequestReviews), varargs...)
	return &MockGiteaReviewRequesterRequestReviewsCall{Call: call}
}

// MockGiteaReviewRequesterRequestReviewsCall wrap *gomock.Call
type MockGiteaReviewRequesterRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewRequesterRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewRequesterRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewRequesterRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewRequesterRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewRequesterRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewRequesterRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaReviewUnrequester is a mock of GiteaReviewUnrequester interface.
type MockGiteaReviewUnrequester struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaReviewUnrequesterMockRecorder
	isgomock struct{}
}

// MockGiteaReviewUnrequesterMockRecorder is the mock recorder for MockGiteaReviewUnrequester.
type MockGiteaReviewUnrequesterMockRecorder struct {
	mock *MockGiteaReviewUnrequester
}

// NewMockGiteaReviewUnrequester creates a new mock instance.
func NewMockGiteaReviewUnrequester(ctrl *gomock.Controller) *MockGiteaReviewUnrequester {
	mock := &MockGiteaReviewUnrequester{ctrl: ctrl}
	mock.recorder = &MockGiteaReviewUnrequesterMockRecorder{mock}
	return mock
}

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

// UnrequestReview mocks base method.
func (m *MockGiteaReviewUnrequester) UnrequestReview(org, repo string, id int64, reviwers ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{org, repo, id}
	for _, a := range reviwers {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnrequestReview", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnrequestReview indicates an expected call of UnrequestReview.
func (mr *MockGiteaReviewUnrequesterMockRecorder) UnrequestReview(org, repo, id any, reviwers ...any) *MockGiteaReviewUnrequesterUnrequestReviewCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{org, repo, id}, reviwers...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrequestReview", reflect.TypeOf((*MockGiteaReviewUnrequester)(nil).UnrequestReview), varargs...)
	return &MockGiteaReviewUnrequesterUnrequestReviewCall{Call: call}
}

// MockGiteaReviewUnrequesterUnrequestReviewCall wrap *gomock.Call
type MockGiteaReviewUnrequesterUnrequestReviewCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) Return(arg0 error) *MockGiteaReviewUnrequesterUnrequestReviewCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) Do(f func(string, string, int64, ...string) error) *MockGiteaReviewUnrequesterUnrequestReviewCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) DoAndReturn(f func(string, string, int64, ...string) error) *MockGiteaReviewUnrequesterUnrequestReviewCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaReviewer is a mock of GiteaReviewer interface.
type MockGiteaReviewer struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaReviewerMockRecorder
	isgomock struct{}
}

// MockGiteaReviewerMockRecorder is the mock recorder for MockGiteaReviewer.
type MockGiteaReviewerMockRecorder struct {
	mock *MockGiteaReviewer
}

// NewMockGiteaReviewer creates a new mock instance.
func NewMockGiteaReviewer(ctrl *gomock.Controller) *MockGiteaReviewer {
	mock := &MockGiteaReviewer{ctrl: ctrl}
	mock.recorder = &MockGiteaReviewerMockRecorder{mock}
	return mock
}

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

// AddReviewComment mocks base method.
func (m *MockGiteaReviewer) AddReviewComment(pr *models.PullRequest, state models.ReviewStateType, comment string) (*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddReviewComment", pr, state, comment)
	ret0, _ := ret[0].(*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddReviewComment indicates an expected call of AddReviewComment.
func (mr *MockGiteaReviewerMockRecorder) AddReviewComment(pr, state, comment any) *MockGiteaReviewerAddReviewCommentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReviewComment", reflect.TypeOf((*MockGiteaReviewer)(nil).AddReviewComment), pr, state, comment)
	return &MockGiteaReviewerAddReviewCommentCall{Call: call}
}

// MockGiteaReviewerAddReviewCommentCall wrap *gomock.Call
type MockGiteaReviewerAddReviewCommentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaReviewerAddReviewCommentCall) Return(arg0 *models.PullReview, arg1 error) *MockGiteaReviewerAddReviewCommentCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaReviewerAddReviewCommentCall) Do(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaReviewerAddReviewCommentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaReviewerAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaReviewerAddReviewCommentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaRepoFetcher is a mock of GiteaRepoFetcher interface.
type MockGiteaRepoFetcher struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaRepoFetcherMockRecorder
	isgomock struct{}
}

// MockGiteaRepoFetcherMockRecorder is the mock recorder for MockGiteaRepoFetcher.
type MockGiteaRepoFetcherMockRecorder struct {
	mock *MockGiteaRepoFetcher
}

// NewMockGiteaRepoFetcher creates a new mock instance.
func NewMockGiteaRepoFetcher(ctrl *gomock.Controller) *MockGiteaRepoFetcher {
	mock := &MockGiteaRepoFetcher{ctrl: ctrl}
	mock.recorder = &MockGiteaRepoFetcherMockRecorder{mock}
	return mock
}

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

// GetRepository mocks base method.
func (m *MockGiteaRepoFetcher) GetRepository(org, repo string) (*models.Repository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepository", org, repo)
	ret0, _ := ret[0].(*models.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRepository indicates an expected call of GetRepository.
func (mr *MockGiteaRepoFetcherMockRecorder) GetRepository(org, repo any) *MockGiteaRepoFetcherGetRepositoryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGiteaRepoFetcher)(nil).GetRepository), org, repo)
	return &MockGiteaRepoFetcherGetRepositoryCall{Call: call}
}

// MockGiteaRepoFetcherGetRepositoryCall wrap *gomock.Call
type MockGiteaRepoFetcherGetRepositoryCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaRepoFetcherGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaRepoFetcherGetRepositoryCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaRepoFetcherGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaRepoFetcherGetRepositoryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaRepoFetcherGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaRepoFetcherGetRepositoryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaFileContentReader is a mock of GiteaFileContentReader interface.
type MockGiteaFileContentReader struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaFileContentReaderMockRecorder
	isgomock struct{}
}

// MockGiteaFileContentReaderMockRecorder is the mock recorder for MockGiteaFileContentReader.
type MockGiteaFileContentReaderMockRecorder struct {
	mock *MockGiteaFileContentReader
}

// NewMockGiteaFileContentReader creates a new mock instance.
func NewMockGiteaFileContentReader(ctrl *gomock.Controller) *MockGiteaFileContentReader {
	mock := &MockGiteaFileContentReader{ctrl: ctrl}
	mock.recorder = &MockGiteaFileContentReaderMockRecorder{mock}
	return mock
}

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

// GetRepositoryFileContent mocks base method.
func (m *MockGiteaFileContentReader) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent.
func (mr *MockGiteaFileContentReaderMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGiteaFileContentReader)(nil).GetRepositoryFileContent), org, repo, hash, path)
	return &MockGiteaFileContentReaderGetRepositoryFileContentCall{Call: call}
}

// MockGiteaFileContentReaderGetRepositoryFileContentCall wrap *gomock.Call
type MockGiteaFileContentReaderGetRepositoryFileContentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaCommitStatusSetter is a mock of GiteaCommitStatusSetter interface.
type MockGiteaCommitStatusSetter struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaCommitStatusSetterMockRecorder
	isgomock struct{}
}

// MockGiteaCommitStatusSetterMockRecorder is the mock recorder for MockGiteaCommitStatusSetter.
type MockGiteaCommitStatusSetterMockRecorder struct {
	mock *MockGiteaCommitStatusSetter
}

// NewMockGiteaCommitStatusSetter creates a new mock instance.
func NewMockGiteaCommitStatusSetter(ctrl *gomock.Controller) *MockGiteaCommitStatusSetter {
	mock := &MockGiteaCommitStatusSetter{ctrl: ctrl}
	mock.recorder = &MockGiteaCommitStatusSetterMockRecorder{mock}
	return mock
}

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

// SetCommitStatus mocks base method.
func (m *MockGiteaCommitStatusSetter) SetCommitStatus(org, repo, hash string, status *models.CommitStatus) (*models.CommitStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCommitStatus", org, repo, hash, status)
	ret0, _ := ret[0].(*models.CommitStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetCommitStatus indicates an expected call of SetCommitStatus.
func (mr *MockGiteaCommitStatusSetterMockRecorder) SetCommitStatus(org, repo, hash, status any) *MockGiteaCommitStatusSetterSetCommitStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockGiteaCommitStatusSetter)(nil).SetCommitStatus), org, repo, hash, status)
	return &MockGiteaCommitStatusSetterSetCommitStatusCall{Call: call}
}

// MockGiteaCommitStatusSetterSetCommitStatusCall wrap *gomock.Call
type MockGiteaCommitStatusSetterSetCommitStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) Return(arg0 *models.CommitStatus, arg1 error) *MockGiteaCommitStatusSetterSetCommitStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) Do(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaCommitStatusSetterSetCommitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) DoAndReturn(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaCommitStatusSetterSetCommitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaCommitStatusGetter is a mock of GiteaCommitStatusGetter interface.
type MockGiteaCommitStatusGetter struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaCommitStatusGetterMockRecorder
	isgomock struct{}
}

// MockGiteaCommitStatusGetterMockRecorder is the mock recorder for MockGiteaCommitStatusGetter.
type MockGiteaCommitStatusGetterMockRecorder struct {
	mock *MockGiteaCommitStatusGetter
}

// NewMockGiteaCommitStatusGetter creates a new mock instance.
func NewMockGiteaCommitStatusGetter(ctrl *gomock.Controller) *MockGiteaCommitStatusGetter {
	mock := &MockGiteaCommitStatusGetter{ctrl: ctrl}
	mock.recorder = &MockGiteaCommitStatusGetterMockRecorder{mock}
	return mock
}

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

// GetCommitStatus mocks base method.
func (m *MockGiteaCommitStatusGetter) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitStatus", org, repo, hash)
	ret0, _ := ret[0].([]*models.CommitStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommitStatus indicates an expected call of GetCommitStatus.
func (mr *MockGiteaCommitStatusGetterMockRecorder) GetCommitStatus(org, repo, hash any) *MockGiteaCommitStatusGetterGetCommitStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatus", reflect.TypeOf((*MockGiteaCommitStatusGetter)(nil).GetCommitStatus), org, repo, hash)
	return &MockGiteaCommitStatusGetterGetCommitStatusCall{Call: call}
}

// MockGiteaCommitStatusGetterGetCommitStatusCall wrap *gomock.Call
type MockGiteaCommitStatusGetterGetCommitStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) Return(arg0 []*models.CommitStatus, arg1 error) *MockGiteaCommitStatusGetterGetCommitStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) Do(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaCommitStatusGetterGetCommitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) DoAndReturn(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaCommitStatusGetterGetCommitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGiteaMerger is a mock of GiteaMerger interface.
type MockGiteaMerger struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaMergerMockRecorder
	isgomock struct{}
}

// MockGiteaMergerMockRecorder is the mock recorder for MockGiteaMerger.
type MockGiteaMergerMockRecorder struct {
	mock *MockGiteaMerger
}

// NewMockGiteaMerger creates a new mock instance.
func NewMockGiteaMerger(ctrl *gomock.Controller) *MockGiteaMerger {
	mock := &MockGiteaMerger{ctrl: ctrl}
	mock.recorder = &MockGiteaMergerMockRecorder{mock}
	return mock
}

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

// ManualMergePR mocks base method.
func (m *MockGiteaMerger) ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ManualMergePR", org, repo, id, commitid, delBranch)
	ret0, _ := ret[0].(error)
	return ret0
}

// ManualMergePR indicates an expected call of ManualMergePR.
func (mr *MockGiteaMergerMockRecorder) ManualMergePR(org, repo, id, commitid, delBranch any) *MockGiteaMergerManualMergePRCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManualMergePR", reflect.TypeOf((*MockGiteaMerger)(nil).ManualMergePR), org, repo, id, commitid, delBranch)
	return &MockGiteaMergerManualMergePRCall{Call: call}
}

// MockGiteaMergerManualMergePRCall wrap *gomock.Call
type MockGiteaMergerManualMergePRCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaMergerManualMergePRCall) Return(arg0 error) *MockGiteaMergerManualMergePRCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaMergerManualMergePRCall) Do(f func(string, string, int64, string, bool) error) *MockGiteaMergerManualMergePRCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaMergerManualMergePRCall) DoAndReturn(f func(string, string, int64, string, bool) error) *MockGiteaMergerManualMergePRCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitea is a mock of Gitea interface.
type MockGitea struct {
	ctrl     *gomock.Controller
	recorder *MockGiteaMockRecorder
	isgomock struct{}
}

// MockGiteaMockRecorder is the mock recorder for MockGitea.
type MockGiteaMockRecorder struct {
	mock *MockGitea
}

// NewMockGitea creates a new mock instance.
func NewMockGitea(ctrl *gomock.Controller) *MockGitea {
	mock := &MockGitea{ctrl: ctrl}
	mock.recorder = &MockGiteaMockRecorder{mock}
	return mock
}

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

// AddComment mocks base method.
func (m *MockGitea) AddComment(pr *models.PullRequest, comment string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddComment", pr, comment)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddComment indicates an expected call of AddComment.
func (mr *MockGiteaMockRecorder) AddComment(pr, comment any) *MockGiteaAddCommentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddComment", reflect.TypeOf((*MockGitea)(nil).AddComment), pr, comment)
	return &MockGiteaAddCommentCall{Call: call}
}

// MockGiteaAddCommentCall wrap *gomock.Call
type MockGiteaAddCommentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaAddCommentCall) Return(arg0 error) *MockGiteaAddCommentCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaAddCommentCall) Do(f func(*models.PullRequest, string) error) *MockGiteaAddCommentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaAddCommentCall) DoAndReturn(f func(*models.PullRequest, string) error) *MockGiteaAddCommentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddReviewComment mocks base method.
func (m *MockGitea) AddReviewComment(pr *models.PullRequest, state models.ReviewStateType, comment string) (*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddReviewComment", pr, state, comment)
	ret0, _ := ret[0].(*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddReviewComment indicates an expected call of AddReviewComment.
func (mr *MockGiteaMockRecorder) AddReviewComment(pr, state, comment any) *MockGiteaAddReviewCommentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReviewComment", reflect.TypeOf((*MockGitea)(nil).AddReviewComment), pr, state, comment)
	return &MockGiteaAddReviewCommentCall{Call: call}
}

// MockGiteaAddReviewCommentCall wrap *gomock.Call
type MockGiteaAddReviewCommentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaAddReviewCommentCall) Return(arg0 *models.PullReview, arg1 error) *MockGiteaAddReviewCommentCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaAddReviewCommentCall) Do(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaAddReviewCommentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaAddReviewCommentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreatePullRequestIfNotExist mocks base method.
func (m *MockGitea) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequestIfNotExist", repo, srcId, targetId, title, body)
	ret0, _ := ret[0].(*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePullRequestIfNotExist indicates an expected call of CreatePullRequestIfNotExist.
func (mr *MockGiteaMockRecorder) CreatePullRequestIfNotExist(repo, srcId, targetId, title, body any) *MockGiteaCreatePullRequestIfNotExistCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestIfNotExist", reflect.TypeOf((*MockGitea)(nil).CreatePullRequestIfNotExist), repo, srcId, targetId, title, body)
	return &MockGiteaCreatePullRequestIfNotExistCall{Call: call}
}

// MockGiteaCreatePullRequestIfNotExistCall wrap *gomock.Call
type MockGiteaCreatePullRequestIfNotExistCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCreatePullRequestIfNotExistCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaCreatePullRequestIfNotExistCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCreatePullRequestIfNotExistCall) Do(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCreatePullRequestIfNotExistCall) DoAndReturn(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateRepositoryIfNotExist mocks base method.
func (m *MockGitea) CreateRepositoryIfNotExist(git common.Git, org, repoName string) (*models.Repository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRepositoryIfNotExist", git, org, repoName)
	ret0, _ := ret[0].(*models.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRepositoryIfNotExist indicates an expected call of CreateRepositoryIfNotExist.
func (mr *MockGiteaMockRecorder) CreateRepositoryIfNotExist(git, org, repoName any) *MockGiteaCreateRepositoryIfNotExistCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepositoryIfNotExist", reflect.TypeOf((*MockGitea)(nil).CreateRepositoryIfNotExist), git, org, repoName)
	return &MockGiteaCreateRepositoryIfNotExistCall{Call: call}
}

// MockGiteaCreateRepositoryIfNotExistCall wrap *gomock.Call
type MockGiteaCreateRepositoryIfNotExistCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaCreateRepositoryIfNotExistCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaCreateRepositoryIfNotExistCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaCreateRepositoryIfNotExistCall) Do(f func(common.Git, string, string) (*models.Repository, error)) *MockGiteaCreateRepositoryIfNotExistCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaCreateRepositoryIfNotExistCall) DoAndReturn(f func(common.Git, string, string) (*models.Repository, error)) *MockGiteaCreateRepositoryIfNotExistCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FetchMaintainershipDirFile mocks base method.
func (m *MockGitea) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile.
func (mr *MockGiteaMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaFetchMaintainershipDirFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGitea)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg)
	return &MockGiteaFetchMaintainershipDirFileCall{Call: call}
}

// MockGiteaFetchMaintainershipDirFileCall wrap *gomock.Call
type MockGiteaFetchMaintainershipDirFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFetchMaintainershipDirFileCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipDirFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipDirFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FetchMaintainershipFile mocks base method.
func (m *MockGitea) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile.
func (mr *MockGiteaMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaFetchMaintainershipFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGitea)(nil).FetchMaintainershipFile), org, prjGit, branch)
	return &MockGiteaFetchMaintainershipFileCall{Call: call}
}

// MockGiteaFetchMaintainershipFileCall wrap *gomock.Call
type MockGiteaFetchMaintainershipFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFetchMaintainershipFileCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommit mocks base method.
func (m *MockGitea) GetCommit(org, repo, sha string) (*models.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", org, repo, sha)
	ret0, _ := ret[0].(*models.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockGiteaMockRecorder) GetCommit(org, repo, sha any) *MockGiteaGetCommitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGitea)(nil).GetCommit), org, repo, sha)
	return &MockGiteaGetCommitCall{Call: call}
}

// MockGiteaGetCommitCall wrap *gomock.Call
type MockGiteaGetCommitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetCommitCall) Return(arg0 *models.Commit, arg1 error) *MockGiteaGetCommitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetCommitCall) Do(f func(string, string, string) (*models.Commit, error)) *MockGiteaGetCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetCommitCall) DoAndReturn(f func(string, string, string) (*models.Commit, error)) *MockGiteaGetCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitStatus mocks base method.
func (m *MockGitea) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitStatus", org, repo, hash)
	ret0, _ := ret[0].([]*models.CommitStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommitStatus indicates an expected call of GetCommitStatus.
func (mr *MockGiteaMockRecorder) GetCommitStatus(org, repo, hash any) *MockGiteaGetCommitStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatus", reflect.TypeOf((*MockGitea)(nil).GetCommitStatus), org, repo, hash)
	return &MockGiteaGetCommitStatusCall{Call: call}
}

// MockGiteaGetCommitStatusCall wrap *gomock.Call
type MockGiteaGetCommitStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetCommitStatusCall) Return(arg0 []*models.CommitStatus, arg1 error) *MockGiteaGetCommitStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetCommitStatusCall) Do(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaGetCommitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetCommitStatusCall) DoAndReturn(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaGetCommitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCurrentUser mocks base method.
func (m *MockGitea) GetCurrentUser() (*models.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentUser")
	ret0, _ := ret[0].(*models.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentUser indicates an expected call of GetCurrentUser.
func (mr *MockGiteaMockRecorder) GetCurrentUser() *MockGiteaGetCurrentUserCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentUser", reflect.TypeOf((*MockGitea)(nil).GetCurrentUser))
	return &MockGiteaGetCurrentUserCall{Call: call}
}

// MockGiteaGetCurrentUserCall wrap *gomock.Call
type MockGiteaGetCurrentUserCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetCurrentUserCall) Return(arg0 *models.User, arg1 error) *MockGiteaGetCurrentUserCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetCurrentUserCall) Do(f func() (*models.User, error)) *MockGiteaGetCurrentUserCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetCurrentUserCall) DoAndReturn(f func() (*models.User, error)) *MockGiteaGetCurrentUserCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetDoneNotifications mocks base method.
func (m *MockGitea) GetDoneNotifications(Type string, page int64) ([]*models.NotificationThread, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDoneNotifications", Type, page)
	ret0, _ := ret[0].([]*models.NotificationThread)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDoneNotifications indicates an expected call of GetDoneNotifications.
func (mr *MockGiteaMockRecorder) GetDoneNotifications(Type, page any) *MockGiteaGetDoneNotificationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDoneNotifications", reflect.TypeOf((*MockGitea)(nil).GetDoneNotifications), Type, page)
	return &MockGiteaGetDoneNotificationsCall{Call: call}
}

// MockGiteaGetDoneNotificationsCall wrap *gomock.Call
type MockGiteaGetDoneNotificationsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetDoneNotificationsCall) Return(arg0 []*models.NotificationThread, arg1 error) *MockGiteaGetDoneNotificationsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetDoneNotificationsCall) Do(f func(string, int64) ([]*models.NotificationThread, error)) *MockGiteaGetDoneNotificationsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetDoneNotificationsCall) DoAndReturn(f func(string, int64) ([]*models.NotificationThread, error)) *MockGiteaGetDoneNotificationsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetIssueComments mocks base method.
func (m *MockGitea) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
	ret0, _ := ret[0].([]*models.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIssueComments indicates an expected call of GetIssueComments.
func (mr *MockGiteaMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaGetIssueCommentsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGitea)(nil).GetIssueComments), org, project, issueNo)
	return &MockGiteaGetIssueCommentsCall{Call: call}
}

// MockGiteaGetIssueCommentsCall wrap *gomock.Call
type MockGiteaGetIssueCommentsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaGetIssueCommentsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaGetIssueCommentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaGetIssueCommentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetNotifications mocks base method.
func (m *MockGitea) GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotifications", Type, since)
	ret0, _ := ret[0].([]*models.NotificationThread)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotifications indicates an expected call of GetNotifications.
func (mr *MockGiteaMockRecorder) GetNotifications(Type, since any) *MockGiteaGetNotificationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotifications", reflect.TypeOf((*MockGitea)(nil).GetNotifications), Type, since)
	return &MockGiteaGetNotificationsCall{Call: call}
}

// MockGiteaGetNotificationsCall wrap *gomock.Call
type MockGiteaGetNotificationsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetNotificationsCall) Return(arg0 []*models.NotificationThread, arg1 error) *MockGiteaGetNotificationsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetNotificationsCall) Do(f func(string, *time.Time) ([]*models.NotificationThread, error)) *MockGiteaGetNotificationsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetNotificationsCall) DoAndReturn(f func(string, *time.Time) ([]*models.NotificationThread, error)) *MockGiteaGetNotificationsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetOrganization mocks base method.
func (m *MockGitea) GetOrganization(orgName string) (*models.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganization", orgName)
	ret0, _ := ret[0].(*models.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganization indicates an expected call of GetOrganization.
func (mr *MockGiteaMockRecorder) GetOrganization(orgName any) *MockGiteaGetOrganizationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganization", reflect.TypeOf((*MockGitea)(nil).GetOrganization), orgName)
	return &MockGiteaGetOrganizationCall{Call: call}
}

// MockGiteaGetOrganizationCall wrap *gomock.Call
type MockGiteaGetOrganizationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetOrganizationCall) Return(arg0 *models.Organization, arg1 error) *MockGiteaGetOrganizationCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetOrganizationCall) Do(f func(string) (*models.Organization, error)) *MockGiteaGetOrganizationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetOrganizationCall) DoAndReturn(f func(string) (*models.Organization, error)) *MockGiteaGetOrganizationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetOrganizationRepositories mocks base method.
func (m *MockGitea) GetOrganizationRepositories(orgName string) ([]*models.Repository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationRepositories", orgName)
	ret0, _ := ret[0].([]*models.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganizationRepositories indicates an expected call of GetOrganizationRepositories.
func (mr *MockGiteaMockRecorder) GetOrganizationRepositories(orgName any) *MockGiteaGetOrganizationRepositoriesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationRepositories", reflect.TypeOf((*MockGitea)(nil).GetOrganizationRepositories), orgName)
	return &MockGiteaGetOrganizationRepositoriesCall{Call: call}
}

// MockGiteaGetOrganizationRepositoriesCall wrap *gomock.Call
type MockGiteaGetOrganizationRepositoriesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetOrganizationRepositoriesCall) Return(arg0 []*models.Repository, arg1 error) *MockGiteaGetOrganizationRepositoriesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetOrganizationRepositoriesCall) Do(f func(string) ([]*models.Repository, error)) *MockGiteaGetOrganizationRepositoriesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetOrganizationRepositoriesCall) DoAndReturn(f func(string) ([]*models.Repository, error)) *MockGiteaGetOrganizationRepositoriesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetPullRequest mocks base method.
func (m *MockGitea) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequest", org, project, num)
	ret0, _ := ret[0].(*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequest indicates an expected call of GetPullRequest.
func (mr *MockGiteaMockRecorder) GetPullRequest(org, project, num any) *MockGiteaGetPullRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGitea)(nil).GetPullRequest), org, project, num)
	return &MockGiteaGetPullRequestCall{Call: call}
}

// MockGiteaGetPullRequestCall wrap *gomock.Call
type MockGiteaGetPullRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaGetPullRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaGetPullRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaGetPullRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetPullRequestFileContent mocks base method.
func (m *MockGitea) GetPullRequestFileContent(pr *models.PullRequest, path string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestFileContent", pr, path)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPullRequestFileContent indicates an expected call of GetPullRequestFileContent.
func (mr *MockGiteaMockRecorder) GetPullRequestFileContent(pr, path any) *MockGiteaGetPullRequestFileContentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestFileContent", reflect.TypeOf((*MockGitea)(nil).GetPullRequestFileContent), pr, path)
	return &MockGiteaGetPullRequestFileContentCall{Call: call}
}

// MockGiteaGetPullRequestFileContentCall wrap *gomock.Call
type MockGiteaGetPullRequestFileContentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetPullRequestFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaGetPullRequestFileContentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetPullRequestFileContentCall) Do(f func(*models.PullRequest, string) ([]byte, string, error)) *MockGiteaGetPullRequestFileContentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetPullRequestFileContentCall) DoAndReturn(f func(*models.PullRequest, string) ([]byte, string, error)) *MockGiteaGetPullRequestFileContentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetPullRequestReviews mocks base method.
func (m *MockGitea) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
func (mr *MockGiteaMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaGetPullRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGitea)(nil).GetPullRequestReviews), org, project, PRnum)
	return &MockGiteaGetPullRequestReviewsCall{Call: call}
}

// MockGiteaGetPullRequestReviewsCall wrap *gomock.Call
type MockGiteaGetPullRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaGetPullRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaGetPullRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaGetPullRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetPullRequests mocks base method.
func (m *MockGitea) GetPullRequests(org, project string) ([]*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequests", org, project)
	ret0, _ := ret[0].([]*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequests indicates an expected call of GetPullRequests.
func (mr *MockGiteaMockRecorder) GetPullRequests(org, project any) *MockGiteaGetPullRequestsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequests", reflect.TypeOf((*MockGitea)(nil).GetPullRequests), org, project)
	return &MockGiteaGetPullRequestsCall{Call: call}
}

// MockGiteaGetPullRequestsCall wrap *gomock.Call
type MockGiteaGetPullRequestsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetPullRequestsCall) Return(arg0 []*models.PullRequest, arg1 error) *MockGiteaGetPullRequestsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetPullRequestsCall) Do(f func(string, string) ([]*models.PullRequest, error)) *MockGiteaGetPullRequestsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetPullRequestsCall) DoAndReturn(f func(string, string) ([]*models.PullRequest, error)) *MockGiteaGetPullRequestsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRecentCommits mocks base method.
func (m *MockGitea) GetRecentCommits(org, repo, branch string, commitNo int64) ([]*models.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecentCommits", org, repo, branch, commitNo)
	ret0, _ := ret[0].([]*models.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRecentCommits indicates an expected call of GetRecentCommits.
func (mr *MockGiteaMockRecorder) GetRecentCommits(org, repo, branch, commitNo any) *MockGiteaGetRecentCommitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecentCommits", reflect.TypeOf((*MockGitea)(nil).GetRecentCommits), org, repo, branch, commitNo)
	return &MockGiteaGetRecentCommitsCall{Call: call}
}

// MockGiteaGetRecentCommitsCall wrap *gomock.Call
type MockGiteaGetRecentCommitsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetRecentCommitsCall) Return(arg0 []*models.Commit, arg1 error) *MockGiteaGetRecentCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetRecentCommitsCall) Do(f func(string, string, string, int64) ([]*models.Commit, error)) *MockGiteaGetRecentCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetRecentCommitsCall) DoAndReturn(f func(string, string, string, int64) ([]*models.Commit, error)) *MockGiteaGetRecentCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRecentPullRequests mocks base method.
func (m *MockGitea) GetRecentPullRequests(org, repo, branch string) ([]*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecentPullRequests", org, repo, branch)
	ret0, _ := ret[0].([]*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRecentPullRequests indicates an expected call of GetRecentPullRequests.
func (mr *MockGiteaMockRecorder) GetRecentPullRequests(org, repo, branch any) *MockGiteaGetRecentPullRequestsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecentPullRequests", reflect.TypeOf((*MockGitea)(nil).GetRecentPullRequests), org, repo, branch)
	return &MockGiteaGetRecentPullRequestsCall{Call: call}
}

// MockGiteaGetRecentPullRequestsCall wrap *gomock.Call
type MockGiteaGetRecentPullRequestsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetRecentPullRequestsCall) Return(arg0 []*models.PullRequest, arg1 error) *MockGiteaGetRecentPullRequestsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetRecentPullRequestsCall) Do(f func(string, string, string) ([]*models.PullRequest, error)) *MockGiteaGetRecentPullRequestsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetRecentPullRequestsCall) DoAndReturn(f func(string, string, string) ([]*models.PullRequest, error)) *MockGiteaGetRecentPullRequestsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRepository mocks base method.
func (m *MockGitea) GetRepository(org, repo string) (*models.Repository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepository", org, repo)
	ret0, _ := ret[0].(*models.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRepository indicates an expected call of GetRepository.
func (mr *MockGiteaMockRecorder) GetRepository(org, repo any) *MockGiteaGetRepositoryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGitea)(nil).GetRepository), org, repo)
	return &MockGiteaGetRepositoryCall{Call: call}
}

// MockGiteaGetRepositoryCall wrap *gomock.Call
type MockGiteaGetRepositoryCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaGetRepositoryCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaGetRepositoryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaGetRepositoryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRepositoryFileContent mocks base method.
func (m *MockGitea) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent.
func (mr *MockGiteaMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaGetRepositoryFileContentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGitea)(nil).GetRepositoryFileContent), org, repo, hash, path)
	return &MockGiteaGetRepositoryFileContentCall{Call: call}
}

// MockGiteaGetRepositoryFileContentCall wrap *gomock.Call
type MockGiteaGetRepositoryFileContentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaGetRepositoryFileContentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaGetRepositoryFileContentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaGetRepositoryFileContentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTimeline mocks base method.
func (m *MockGitea) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
	ret0, _ := ret[0].([]*models.TimelineComment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimeline indicates an expected call of GetTimeline.
func (mr *MockGiteaMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaGetTimelineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGitea)(nil).GetTimeline), org, repo, idx)
	return &MockGiteaGetTimelineCall{Call: call}
}

// MockGiteaGetTimelineCall wrap *gomock.Call
type MockGiteaGetTimelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaGetTimelineCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaGetTimelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaGetTimelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ManualMergePR mocks base method.
func (m *MockGitea) ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ManualMergePR", org, repo, id, commitid, delBranch)
	ret0, _ := ret[0].(error)
	return ret0
}

// ManualMergePR indicates an expected call of ManualMergePR.
func (mr *MockGiteaMockRecorder) ManualMergePR(org, repo, id, commitid, delBranch any) *MockGiteaManualMergePRCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManualMergePR", reflect.TypeOf((*MockGitea)(nil).ManualMergePR), org, repo, id, commitid, delBranch)
	return &MockGiteaManualMergePRCall{Call: call}
}

// MockGiteaManualMergePRCall wrap *gomock.Call
type MockGiteaManualMergePRCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaManualMergePRCall) Return(arg0 error) *MockGiteaManualMergePRCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaManualMergePRCall) Do(f func(string, string, int64, string, bool) error) *MockGiteaManualMergePRCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaManualMergePRCall) DoAndReturn(f func(string, string, int64, string, bool) error) *MockGiteaManualMergePRCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RequestReviews mocks base method.
func (m *MockGitea) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) {
	m.ctrl.T.Helper()
	varargs := []any{pr}
	for _, a := range reviewer {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestReviews", varargs...)
	ret0, _ := ret[0].([]*models.PullReview)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RequestReviews indicates an expected call of RequestReviews.
func (mr *MockGiteaMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaRequestReviewsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pr}, reviewer...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGitea)(nil).RequestReviews), varargs...)
	return &MockGiteaRequestReviewsCall{Call: call}
}

// MockGiteaRequestReviewsCall wrap *gomock.Call
type MockGiteaRequestReviewsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaRequestReviewsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaRequestReviewsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaRequestReviewsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetCommitStatus mocks base method.
func (m *MockGitea) SetCommitStatus(org, repo, hash string, status *models.CommitStatus) (*models.CommitStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCommitStatus", org, repo, hash, status)
	ret0, _ := ret[0].(*models.CommitStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetCommitStatus indicates an expected call of SetCommitStatus.
func (mr *MockGiteaMockRecorder) SetCommitStatus(org, repo, hash, status any) *MockGiteaSetCommitStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockGitea)(nil).SetCommitStatus), org, repo, hash, status)
	return &MockGiteaSetCommitStatusCall{Call: call}
}

// MockGiteaSetCommitStatusCall wrap *gomock.Call
type MockGiteaSetCommitStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaSetCommitStatusCall) Return(arg0 *models.CommitStatus, arg1 error) *MockGiteaSetCommitStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaSetCommitStatusCall) Do(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaSetCommitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaSetCommitStatusCall) DoAndReturn(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaSetCommitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetNotificationRead mocks base method.
func (m *MockGitea) SetNotificationRead(notificationId int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNotificationRead", notificationId)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetNotificationRead indicates an expected call of SetNotificationRead.
func (mr *MockGiteaMockRecorder) SetNotificationRead(notificationId any) *MockGiteaSetNotificationReadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNotificationRead", reflect.TypeOf((*MockGitea)(nil).SetNotificationRead), notificationId)
	return &MockGiteaSetNotificationReadCall{Call: call}
}

// MockGiteaSetNotificationReadCall wrap *gomock.Call
type MockGiteaSetNotificationReadCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaSetNotificationReadCall) Return(arg0 error) *MockGiteaSetNotificationReadCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaSetNotificationReadCall) Do(f func(int64) error) *MockGiteaSetNotificationReadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaSetNotificationReadCall) DoAndReturn(f func(int64) error) *MockGiteaSetNotificationReadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetRepoOptions mocks base method.
func (m *MockGitea) SetRepoOptions(owner, repo string, manual_merge bool) (*models.Repository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRepoOptions", owner, repo, manual_merge)
	ret0, _ := ret[0].(*models.Repository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetRepoOptions indicates an expected call of SetRepoOptions.
func (mr *MockGiteaMockRecorder) SetRepoOptions(owner, repo, manual_merge any) *MockGiteaSetRepoOptionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepoOptions", reflect.TypeOf((*MockGitea)(nil).SetRepoOptions), owner, repo, manual_merge)
	return &MockGiteaSetRepoOptionsCall{Call: call}
}

// MockGiteaSetRepoOptionsCall wrap *gomock.Call
type MockGiteaSetRepoOptionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaSetRepoOptionsCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaSetRepoOptionsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaSetRepoOptionsCall) Do(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaSetRepoOptionsCall) DoAndReturn(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnrequestReview mocks base method.
func (m *MockGitea) UnrequestReview(org, repo string, id int64, reviwers ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{org, repo, id}
	for _, a := range reviwers {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnrequestReview", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnrequestReview indicates an expected call of UnrequestReview.
func (mr *MockGiteaMockRecorder) UnrequestReview(org, repo, id any, reviwers ...any) *MockGiteaUnrequestReviewCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{org, repo, id}, reviwers...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrequestReview", reflect.TypeOf((*MockGitea)(nil).UnrequestReview), varargs...)
	return &MockGiteaUnrequestReviewCall{Call: call}
}

// MockGiteaUnrequestReviewCall wrap *gomock.Call
type MockGiteaUnrequestReviewCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaUnrequestReviewCall) Return(arg0 error) *MockGiteaUnrequestReviewCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaUnrequestReviewCall) Do(f func(string, string, int64, ...string) error) *MockGiteaUnrequestReviewCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaUnrequestReviewCall) DoAndReturn(f func(string, string, int64, ...string) error) *MockGiteaUnrequestReviewCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatePullRequest mocks base method.
func (m *MockGitea) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequest", org, repo, num, options)
	ret0, _ := ret[0].(*models.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePullRequest indicates an expected call of UpdatePullRequest.
func (mr *MockGiteaMockRecorder) UpdatePullRequest(org, repo, num, options any) *MockGiteaUpdatePullRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGitea)(nil).UpdatePullRequest), org, repo, num, options)
	return &MockGiteaUpdatePullRequestCall{Call: call}
}

// MockGiteaUpdatePullRequestCall wrap *gomock.Call
type MockGiteaUpdatePullRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGiteaUpdatePullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaUpdatePullRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGiteaUpdatePullRequestCall) Do(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaUpdatePullRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGiteaUpdatePullRequestCall) DoAndReturn(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaUpdatePullRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}