git_sdk_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/microsoft/azure-devops-go-api/azuredevops/git (interfaces: Client)

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

import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	core "github.com/microsoft/azure-devops-go-api/azuredevops/core"
	git "github.com/microsoft/azure-devops-go-api/azuredevops/git"
	webapi "github.com/microsoft/azure-devops-go-api/azuredevops/webapi"
	io "io"
	reflect "reflect"
)

// MockGitClient is a mock of Client interface
type MockGitClient struct {
	ctrl     *gomock.Controller
	recorder *MockGitClientMockRecorder
}

// MockGitClientMockRecorder is the mock recorder for MockGitClient
type MockGitClientMockRecorder struct {
	mock *MockGitClient
}

// NewMockGitClient creates a new mock instance
func NewMockGitClient(ctrl *gomock.Controller) *MockGitClient {
	mock := &MockGitClient{ctrl: ctrl}
	mock.recorder = &MockGitClientMockRecorder{mock}
	return mock
}

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

// CreateAnnotatedTag mocks base method
func (m *MockGitClient) CreateAnnotatedTag(arg0 context.Context, arg1 git.CreateAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAnnotatedTag", arg0, arg1)
	ret0, _ := ret[0].(*git.GitAnnotatedTag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAttachment mocks base method
func (m *MockGitClient) CreateAttachment(arg0 context.Context, arg1 git.CreateAttachmentArgs) (*git.Attachment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAttachment", arg0, arg1)
	ret0, _ := ret[0].(*git.Attachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCherryPick mocks base method
func (m *MockGitClient) CreateCherryPick(arg0 context.Context, arg1 git.CreateCherryPickArgs) (*git.GitCherryPick, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCherryPick", arg0, arg1)
	ret0, _ := ret[0].(*git.GitCherryPick)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateComment mocks base method
func (m *MockGitClient) CreateComment(arg0 context.Context, arg1 git.CreateCommentArgs) (*git.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateComment", arg0, arg1)
	ret0, _ := ret[0].(*git.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCommitStatus mocks base method
func (m *MockGitClient) CreateCommitStatus(arg0 context.Context, arg1 git.CreateCommitStatusArgs) (*git.GitStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCommitStatus", arg0, arg1)
	ret0, _ := ret[0].(*git.GitStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFavorite mocks base method
func (m *MockGitClient) CreateFavorite(arg0 context.Context, arg1 git.CreateFavoriteArgs) (*git.GitRefFavorite, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFavorite", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRefFavorite)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateForkSyncRequest mocks base method
func (m *MockGitClient) CreateForkSyncRequest(arg0 context.Context, arg1 git.CreateForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateForkSyncRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitForkSyncRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateImportRequest mocks base method
func (m *MockGitClient) CreateImportRequest(arg0 context.Context, arg1 git.CreateImportRequestArgs) (*git.GitImportRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImportRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitImportRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLike mocks base method
func (m *MockGitClient) CreateLike(arg0 context.Context, arg1 git.CreateLikeArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLike", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateMergeRequest mocks base method
func (m *MockGitClient) CreateMergeRequest(arg0 context.Context, arg1 git.CreateMergeRequestArgs) (*git.GitMerge, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMergeRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitMerge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePullRequest mocks base method
func (m *MockGitClient) CreatePullRequest(arg0 context.Context, arg1 git.CreatePullRequestArgs) (*git.GitPullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePullRequestIterationStatus mocks base method
func (m *MockGitClient) CreatePullRequestIterationStatus(arg0 context.Context, arg1 git.CreatePullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequestIterationStatus", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePullRequestLabel mocks base method
func (m *MockGitClient) CreatePullRequestLabel(arg0 context.Context, arg1 git.CreatePullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequestLabel", arg0, arg1)
	ret0, _ := ret[0].(*core.WebApiTagDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePullRequestReviewer mocks base method
func (m *MockGitClient) CreatePullRequestReviewer(arg0 context.Context, arg1 git.CreatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequestReviewer", arg0, arg1)
	ret0, _ := ret[0].(*git.IdentityRefWithVote)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePullRequestReviewers mocks base method
func (m *MockGitClient) CreatePullRequestReviewers(arg0 context.Context, arg1 git.CreatePullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequestReviewers", arg0, arg1)
	ret0, _ := ret[0].(*[]git.IdentityRefWithVote)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePullRequestStatus mocks base method
func (m *MockGitClient) CreatePullRequestStatus(arg0 context.Context, arg1 git.CreatePullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePullRequestStatus", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePush mocks base method
func (m *MockGitClient) CreatePush(arg0 context.Context, arg1 git.CreatePushArgs) (*git.GitPush, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePush", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPush)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRepository mocks base method
func (m *MockGitClient) CreateRepository(arg0 context.Context, arg1 git.CreateRepositoryArgs) (*git.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRepository", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRevert mocks base method
func (m *MockGitClient) CreateRevert(arg0 context.Context, arg1 git.CreateRevertArgs) (*git.GitRevert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRevert", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRevert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateThread mocks base method
func (m *MockGitClient) CreateThread(arg0 context.Context, arg1 git.CreateThreadArgs) (*git.GitPullRequestCommentThread, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateThread", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestCommentThread)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAttachment mocks base method
func (m *MockGitClient) DeleteAttachment(arg0 context.Context, arg1 git.DeleteAttachmentArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAttachment", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteComment mocks base method
func (m *MockGitClient) DeleteComment(arg0 context.Context, arg1 git.DeleteCommentArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteComment", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteLike mocks base method
func (m *MockGitClient) DeleteLike(arg0 context.Context, arg1 git.DeleteLikeArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLike", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeletePullRequestIterationStatus mocks base method
func (m *MockGitClient) DeletePullRequestIterationStatus(arg0 context.Context, arg1 git.DeletePullRequestIterationStatusArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePullRequestIterationStatus", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeletePullRequestLabels mocks base method
func (m *MockGitClient) DeletePullRequestLabels(arg0 context.Context, arg1 git.DeletePullRequestLabelsArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePullRequestLabels", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeletePullRequestReviewer mocks base method
func (m *MockGitClient) DeletePullRequestReviewer(arg0 context.Context, arg1 git.DeletePullRequestReviewerArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePullRequestReviewer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeletePullRequestStatus mocks base method
func (m *MockGitClient) DeletePullRequestStatus(arg0 context.Context, arg1 git.DeletePullRequestStatusArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePullRequestStatus", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteRefFavorite mocks base method
func (m *MockGitClient) DeleteRefFavorite(arg0 context.Context, arg1 git.DeleteRefFavoriteArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRefFavorite", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteRepository mocks base method
func (m *MockGitClient) DeleteRepository(arg0 context.Context, arg1 git.DeleteRepositoryArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRepository", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteRepositoryFromRecycleBin mocks base method
func (m *MockGitClient) DeleteRepositoryFromRecycleBin(arg0 context.Context, arg1 git.DeleteRepositoryFromRecycleBinArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRepositoryFromRecycleBin", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetAnnotatedTag mocks base method
func (m *MockGitClient) GetAnnotatedTag(arg0 context.Context, arg1 git.GetAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAnnotatedTag", arg0, arg1)
	ret0, _ := ret[0].(*git.GitAnnotatedTag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAttachmentContent mocks base method
func (m *MockGitClient) GetAttachmentContent(arg0 context.Context, arg1 git.GetAttachmentContentArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttachmentContent", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAttachmentZip mocks base method
func (m *MockGitClient) GetAttachmentZip(arg0 context.Context, arg1 git.GetAttachmentZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttachmentZip", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAttachments mocks base method
func (m *MockGitClient) GetAttachments(arg0 context.Context, arg1 git.GetAttachmentsArgs) (*[]git.Attachment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttachments", arg0, arg1)
	ret0, _ := ret[0].(*[]git.Attachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlob mocks base method
func (m *MockGitClient) GetBlob(arg0 context.Context, arg1 git.GetBlobArgs) (*git.GitBlobRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlob", arg0, arg1)
	ret0, _ := ret[0].(*git.GitBlobRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlobContent mocks base method
func (m *MockGitClient) GetBlobContent(arg0 context.Context, arg1 git.GetBlobContentArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlobContent", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlobZip mocks base method
func (m *MockGitClient) GetBlobZip(arg0 context.Context, arg1 git.GetBlobZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlobZip", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlobsZip mocks base method
func (m *MockGitClient) GetBlobsZip(arg0 context.Context, arg1 git.GetBlobsZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlobsZip", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBranch mocks base method
func (m *MockGitClient) GetBranch(arg0 context.Context, arg1 git.GetBranchArgs) (*git.GitBranchStats, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", arg0, arg1)
	ret0, _ := ret[0].(*git.GitBranchStats)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBranches mocks base method
func (m *MockGitClient) GetBranches(arg0 context.Context, arg1 git.GetBranchesArgs) (*[]git.GitBranchStats, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranches", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitBranchStats)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChanges mocks base method
func (m *MockGitClient) GetChanges(arg0 context.Context, arg1 git.GetChangesArgs) (*git.GitCommitChanges, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChanges", arg0, arg1)
	ret0, _ := ret[0].(*git.GitCommitChanges)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCherryPick mocks base method
func (m *MockGitClient) GetCherryPick(arg0 context.Context, arg1 git.GetCherryPickArgs) (*git.GitCherryPick, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCherryPick", arg0, arg1)
	ret0, _ := ret[0].(*git.GitCherryPick)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCherryPickForRefName mocks base method
func (m *MockGitClient) GetCherryPickForRefName(arg0 context.Context, arg1 git.GetCherryPickForRefNameArgs) (*git.GitCherryPick, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCherryPickForRefName", arg0, arg1)
	ret0, _ := ret[0].(*git.GitCherryPick)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetComment mocks base method
func (m *MockGitClient) GetComment(arg0 context.Context, arg1 git.GetCommentArgs) (*git.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComment", arg0, arg1)
	ret0, _ := ret[0].(*git.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetComments mocks base method
func (m *MockGitClient) GetComments(arg0 context.Context, arg1 git.GetCommentsArgs) (*[]git.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComments", arg0, arg1)
	ret0, _ := ret[0].(*[]git.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCommit mocks base method
func (m *MockGitClient) GetCommit(arg0 context.Context, arg1 git.GetCommitArgs) (*git.GitCommit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", arg0, arg1)
	ret0, _ := ret[0].(*git.GitCommit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCommitDiffs mocks base method
func (m *MockGitClient) GetCommitDiffs(arg0 context.Context, arg1 git.GetCommitDiffsArgs) (*git.GitCommitDiffs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitDiffs", arg0, arg1)
	ret0, _ := ret[0].(*git.GitCommitDiffs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCommits mocks base method
func (m *MockGitClient) GetCommits(arg0 context.Context, arg1 git.GetCommitsArgs) (*[]git.GitCommitRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommits", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitCommitRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCommitsBatch mocks base method
func (m *MockGitClient) GetCommitsBatch(arg0 context.Context, arg1 git.GetCommitsBatchArgs) (*[]git.GitCommitRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitsBatch", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitCommitRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDeletedRepositories mocks base method
func (m *MockGitClient) GetDeletedRepositories(arg0 context.Context, arg1 git.GetDeletedRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeletedRepositories", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitDeletedRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetForkSyncRequest mocks base method
func (m *MockGitClient) GetForkSyncRequest(arg0 context.Context, arg1 git.GetForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetForkSyncRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitForkSyncRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetForkSyncRequests mocks base method
func (m *MockGitClient) GetForkSyncRequests(arg0 context.Context, arg1 git.GetForkSyncRequestsArgs) (*[]git.GitForkSyncRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetForkSyncRequests", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitForkSyncRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetForks mocks base method
func (m *MockGitClient) GetForks(arg0 context.Context, arg1 git.GetForksArgs) (*[]git.GitRepositoryRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetForks", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitRepositoryRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetImportRequest mocks base method
func (m *MockGitClient) GetImportRequest(arg0 context.Context, arg1 git.GetImportRequestArgs) (*git.GitImportRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImportRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitImportRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetItem mocks base method
func (m *MockGitClient) GetItem(arg0 context.Context, arg1 git.GetItemArgs) (*git.GitItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItem", arg0, arg1)
	ret0, _ := ret[0].(*git.GitItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetItemContent mocks base method
func (m *MockGitClient) GetItemContent(arg0 context.Context, arg1 git.GetItemContentArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItemContent", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetItemText mocks base method
func (m *MockGitClient) GetItemText(arg0 context.Context, arg1 git.GetItemTextArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItemText", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetItemZip mocks base method
func (m *MockGitClient) GetItemZip(arg0 context.Context, arg1 git.GetItemZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItemZip", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetItems mocks base method
func (m *MockGitClient) GetItems(arg0 context.Context, arg1 git.GetItemsArgs) (*[]git.GitItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItems", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetItemsBatch mocks base method
func (m *MockGitClient) GetItemsBatch(arg0 context.Context, arg1 git.GetItemsBatchArgs) (*[][]git.GitItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItemsBatch", arg0, arg1)
	ret0, _ := ret[0].(*[][]git.GitItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLikes mocks base method
func (m *MockGitClient) GetLikes(arg0 context.Context, arg1 git.GetLikesArgs) (*[]webapi.IdentityRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLikes", arg0, arg1)
	ret0, _ := ret[0].(*[]webapi.IdentityRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMergeBases mocks base method
func (m *MockGitClient) GetMergeBases(arg0 context.Context, arg1 git.GetMergeBasesArgs) (*[]git.GitCommitRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMergeBases", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitCommitRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMergeRequest mocks base method
func (m *MockGitClient) GetMergeRequest(arg0 context.Context, arg1 git.GetMergeRequestArgs) (*git.GitMerge, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMergeRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitMerge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPolicyConfigurations mocks base method
func (m *MockGitClient) GetPolicyConfigurations(arg0 context.Context, arg1 git.GetPolicyConfigurationsArgs) (*git.GitPolicyConfigurationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyConfigurations", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPolicyConfigurationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequest mocks base method
func (m *MockGitClient) GetPullRequest(arg0 context.Context, arg1 git.GetPullRequestArgs) (*git.GitPullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestById mocks base method
func (m *MockGitClient) GetPullRequestById(arg0 context.Context, arg1 git.GetPullRequestByIdArgs) (*git.GitPullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestById", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestCommits mocks base method
func (m *MockGitClient) GetPullRequestCommits(arg0 context.Context, arg1 git.GetPullRequestCommitsArgs) (*git.GetPullRequestCommitsResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestCommits", arg0, arg1)
	ret0, _ := ret[0].(*git.GetPullRequestCommitsResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestIteration mocks base method
func (m *MockGitClient) GetPullRequestIteration(arg0 context.Context, arg1 git.GetPullRequestIterationArgs) (*git.GitPullRequestIteration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestIteration", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestIteration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestIterationChanges mocks base method
func (m *MockGitClient) GetPullRequestIterationChanges(arg0 context.Context, arg1 git.GetPullRequestIterationChangesArgs) (*git.GitPullRequestIterationChanges, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestIterationChanges", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestIterationChanges)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestIterationCommits mocks base method
func (m *MockGitClient) GetPullRequestIterationCommits(arg0 context.Context, arg1 git.GetPullRequestIterationCommitsArgs) (*[]git.GitCommitRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestIterationCommits", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitCommitRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestIterationStatus mocks base method
func (m *MockGitClient) GetPullRequestIterationStatus(arg0 context.Context, arg1 git.GetPullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestIterationStatus", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestIterationStatuses mocks base method
func (m *MockGitClient) GetPullRequestIterationStatuses(arg0 context.Context, arg1 git.GetPullRequestIterationStatusesArgs) (*[]git.GitPullRequestStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestIterationStatuses", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPullRequestStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestIterations mocks base method
func (m *MockGitClient) GetPullRequestIterations(arg0 context.Context, arg1 git.GetPullRequestIterationsArgs) (*[]git.GitPullRequestIteration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestIterations", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPullRequestIteration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestLabel mocks base method
func (m *MockGitClient) GetPullRequestLabel(arg0 context.Context, arg1 git.GetPullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestLabel", arg0, arg1)
	ret0, _ := ret[0].(*core.WebApiTagDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestLabels mocks base method
func (m *MockGitClient) GetPullRequestLabels(arg0 context.Context, arg1 git.GetPullRequestLabelsArgs) (*[]core.WebApiTagDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestLabels", arg0, arg1)
	ret0, _ := ret[0].(*[]core.WebApiTagDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestProperties mocks base method
func (m *MockGitClient) GetPullRequestProperties(arg0 context.Context, arg1 git.GetPullRequestPropertiesArgs) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestProperties", arg0, arg1)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestQuery mocks base method
func (m *MockGitClient) GetPullRequestQuery(arg0 context.Context, arg1 git.GetPullRequestQueryArgs) (*git.GitPullRequestQuery, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestQuery", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestQuery)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestReviewer mocks base method
func (m *MockGitClient) GetPullRequestReviewer(arg0 context.Context, arg1 git.GetPullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviewer", arg0, arg1)
	ret0, _ := ret[0].(*git.IdentityRefWithVote)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestReviewers mocks base method
func (m *MockGitClient) GetPullRequestReviewers(arg0 context.Context, arg1 git.GetPullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviewers", arg0, arg1)
	ret0, _ := ret[0].(*[]git.IdentityRefWithVote)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestStatus mocks base method
func (m *MockGitClient) GetPullRequestStatus(arg0 context.Context, arg1 git.GetPullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestStatus", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestStatuses mocks base method
func (m *MockGitClient) GetPullRequestStatuses(arg0 context.Context, arg1 git.GetPullRequestStatusesArgs) (*[]git.GitPullRequestStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestStatuses", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPullRequestStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestThread mocks base method
func (m *MockGitClient) GetPullRequestThread(arg0 context.Context, arg1 git.GetPullRequestThreadArgs) (*git.GitPullRequestCommentThread, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestThread", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestCommentThread)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestWorkItemRefs mocks base method
func (m *MockGitClient) GetPullRequestWorkItemRefs(arg0 context.Context, arg1 git.GetPullRequestWorkItemRefsArgs) (*[]webapi.ResourceRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestWorkItemRefs", arg0, arg1)
	ret0, _ := ret[0].(*[]webapi.ResourceRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequests mocks base method
func (m *MockGitClient) GetPullRequests(arg0 context.Context, arg1 git.GetPullRequestsArgs) (*[]git.GitPullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequests", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPullRequestsByProject mocks base method
func (m *MockGitClient) GetPullRequestsByProject(arg0 context.Context, arg1 git.GetPullRequestsByProjectArgs) (*[]git.GitPullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestsByProject", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPush mocks base method
func (m *MockGitClient) GetPush(arg0 context.Context, arg1 git.GetPushArgs) (*git.GitPush, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPush", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPush)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPushCommits mocks base method
func (m *MockGitClient) GetPushCommits(arg0 context.Context, arg1 git.GetPushCommitsArgs) (*[]git.GitCommitRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPushCommits", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitCommitRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPushes mocks base method
func (m *MockGitClient) GetPushes(arg0 context.Context, arg1 git.GetPushesArgs) (*[]git.GitPush, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPushes", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPush)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRecycleBinRepositories mocks base method
func (m *MockGitClient) GetRecycleBinRepositories(arg0 context.Context, arg1 git.GetRecycleBinRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecycleBinRepositories", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitDeletedRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRefFavorite mocks base method
func (m *MockGitClient) GetRefFavorite(arg0 context.Context, arg1 git.GetRefFavoriteArgs) (*git.GitRefFavorite, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRefFavorite", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRefFavorite)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRefFavorites mocks base method
func (m *MockGitClient) GetRefFavorites(arg0 context.Context, arg1 git.GetRefFavoritesArgs) (*[]git.GitRefFavorite, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRefFavorites", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitRefFavorite)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRefs mocks base method
func (m *MockGitClient) GetRefs(arg0 context.Context, arg1 git.GetRefsArgs) (*git.GetRefsResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRefs", arg0, arg1)
	ret0, _ := ret[0].(*git.GetRefsResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRepositories mocks base method
func (m *MockGitClient) GetRepositories(arg0 context.Context, arg1 git.GetRepositoriesArgs) (*[]git.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepositories", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRepository mocks base method
func (m *MockGitClient) GetRepository(arg0 context.Context, arg1 git.GetRepositoryArgs) (*git.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepository", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRepositoryWithParent mocks base method
func (m *MockGitClient) GetRepositoryWithParent(arg0 context.Context, arg1 git.GetRepositoryWithParentArgs) (*git.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepositoryWithParent", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRevert mocks base method
func (m *MockGitClient) GetRevert(arg0 context.Context, arg1 git.GetRevertArgs) (*git.GitRevert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRevert", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRevert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRevertForRefName mocks base method
func (m *MockGitClient) GetRevertForRefName(arg0 context.Context, arg1 git.GetRevertForRefNameArgs) (*git.GitRevert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRevertForRefName", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRevert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStatuses mocks base method
func (m *MockGitClient) GetStatuses(arg0 context.Context, arg1 git.GetStatusesArgs) (*[]git.GitStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatuses", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSuggestions mocks base method
func (m *MockGitClient) GetSuggestions(arg0 context.Context, arg1 git.GetSuggestionsArgs) (*[]git.GitSuggestion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSuggestions", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitSuggestion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetThreads mocks base method
func (m *MockGitClient) GetThreads(arg0 context.Context, arg1 git.GetThreadsArgs) (*[]git.GitPullRequestCommentThread, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThreads", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitPullRequestCommentThread)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTree mocks base method
func (m *MockGitClient) GetTree(arg0 context.Context, arg1 git.GetTreeArgs) (*git.GitTreeRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTree", arg0, arg1)
	ret0, _ := ret[0].(*git.GitTreeRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTreeZip mocks base method
func (m *MockGitClient) GetTreeZip(arg0 context.Context, arg1 git.GetTreeZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTreeZip", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryImportRequests mocks base method
func (m *MockGitClient) QueryImportRequests(arg0 context.Context, arg1 git.QueryImportRequestsArgs) (*[]git.GitImportRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryImportRequests", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitImportRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreRepositoryFromRecycleBin mocks base method
func (m *MockGitClient) RestoreRepositoryFromRecycleBin(arg0 context.Context, arg1 git.RestoreRepositoryFromRecycleBinArgs) (*git.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreRepositoryFromRecycleBin", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SharePullRequest mocks base method
func (m *MockGitClient) SharePullRequest(arg0 context.Context, arg1 git.SharePullRequestArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SharePullRequest", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateComment mocks base method
func (m *MockGitClient) UpdateComment(arg0 context.Context, arg1 git.UpdateCommentArgs) (*git.Comment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateComment", arg0, arg1)
	ret0, _ := ret[0].(*git.Comment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateImportRequest mocks base method
func (m *MockGitClient) UpdateImportRequest(arg0 context.Context, arg1 git.UpdateImportRequestArgs) (*git.GitImportRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateImportRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitImportRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePullRequest mocks base method
func (m *MockGitClient) UpdatePullRequest(arg0 context.Context, arg1 git.UpdatePullRequestArgs) (*git.GitPullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequest", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePullRequestIterationStatuses mocks base method
func (m *MockGitClient) UpdatePullRequestIterationStatuses(arg0 context.Context, arg1 git.UpdatePullRequestIterationStatusesArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequestIterationStatuses", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdatePullRequestProperties mocks base method
func (m *MockGitClient) UpdatePullRequestProperties(arg0 context.Context, arg1 git.UpdatePullRequestPropertiesArgs) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequestProperties", arg0, arg1)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePullRequestReviewers mocks base method
func (m *MockGitClient) UpdatePullRequestReviewers(arg0 context.Context, arg1 git.UpdatePullRequestReviewersArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequestReviewers", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdatePullRequestStatuses mocks base method
func (m *MockGitClient) UpdatePullRequestStatuses(arg0 context.Context, arg1 git.UpdatePullRequestStatusesArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequestStatuses", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateRef mocks base method
func (m *MockGitClient) UpdateRef(arg0 context.Context, arg1 git.UpdateRefArgs) (*git.GitRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRef", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRefs mocks base method
func (m *MockGitClient) UpdateRefs(arg0 context.Context, arg1 git.UpdateRefsArgs) (*[]git.GitRefUpdateResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRefs", arg0, arg1)
	ret0, _ := ret[0].(*[]git.GitRefUpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRepository mocks base method
func (m *MockGitClient) UpdateRepository(arg0 context.Context, arg1 git.UpdateRepositoryArgs) (*git.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRepository", arg0, arg1)
	ret0, _ := ret[0].(*git.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateThread mocks base method
func (m *MockGitClient) UpdateThread(arg0 context.Context, arg1 git.UpdateThreadArgs) (*git.GitPullRequestCommentThread, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateThread", arg0, arg1)
	ret0, _ := ret[0].(*git.GitPullRequestCommentThread)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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