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

package mocks

import (
	context "context"

	core "github.com/microsoft/azure-devops-go-api/azuredevops/core"
	git "github.com/microsoft/azure-devops-go-api/azuredevops/git"

	io "io"

	mock "github.com/stretchr/testify/mock"

	webapi "github.com/microsoft/azure-devops-go-api/azuredevops/webapi"
)

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

// CreateAnnotatedTag provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateAnnotatedTag(_a0 context.Context, _a1 git.CreateAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitAnnotatedTag
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateAnnotatedTagArgs) *git.GitAnnotatedTag); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitAnnotatedTag)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateAnnotatedTagArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAttachment provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateAttachment(_a0 context.Context, _a1 git.CreateAttachmentArgs) (*git.Attachment, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.Attachment
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateAttachmentArgs) *git.Attachment); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Attachment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateAttachmentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCherryPick provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateCherryPick(_a0 context.Context, _a1 git.CreateCherryPickArgs) (*git.GitCherryPick, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitCherryPick
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateCherryPickArgs) *git.GitCherryPick); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCherryPick)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateCherryPickArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateComment provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateComment(_a0 context.Context, _a1 git.CreateCommentArgs) (*git.Comment, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.Comment
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateCommentArgs) *git.Comment); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Comment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateCommentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCommitStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateCommitStatus(_a0 context.Context, _a1 git.CreateCommitStatusArgs) (*git.GitStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateCommitStatusArgs) *git.GitStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateCommitStatusArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFavorite provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateFavorite(_a0 context.Context, _a1 git.CreateFavoriteArgs) (*git.GitRefFavorite, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRefFavorite
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateFavoriteArgs) *git.GitRefFavorite); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRefFavorite)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateFavoriteArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateForkSyncRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateForkSyncRequest(_a0 context.Context, _a1 git.CreateForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitForkSyncRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateForkSyncRequestArgs) *git.GitForkSyncRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitForkSyncRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateForkSyncRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateImportRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateImportRequest(_a0 context.Context, _a1 git.CreateImportRequestArgs) (*git.GitImportRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitImportRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateImportRequestArgs) *git.GitImportRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitImportRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateImportRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateLike provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateLike(_a0 context.Context, _a1 git.CreateLikeArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// CreateMergeRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateMergeRequest(_a0 context.Context, _a1 git.CreateMergeRequestArgs) (*git.GitMerge, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitMerge
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateMergeRequestArgs) *git.GitMerge); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitMerge)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateMergeRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePullRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePullRequest(_a0 context.Context, _a1 git.CreatePullRequestArgs) (*git.GitPullRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestArgs) *git.GitPullRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePullRequestIterationStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePullRequestIterationStatus(_a0 context.Context, _a1 git.CreatePullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestIterationStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestIterationStatusArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePullRequestLabel provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePullRequestLabel(_a0 context.Context, _a1 git.CreatePullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *core.WebApiTagDefinition
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestLabelArgs) *core.WebApiTagDefinition); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*core.WebApiTagDefinition)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestLabelArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePullRequestReviewer provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePullRequestReviewer(_a0 context.Context, _a1 git.CreatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.IdentityRefWithVote
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestReviewerArgs) *git.IdentityRefWithVote); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.IdentityRefWithVote)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestReviewerArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePullRequestReviewers provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePullRequestReviewers(_a0 context.Context, _a1 git.CreatePullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.IdentityRefWithVote
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestReviewersArgs) *[]git.IdentityRefWithVote); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.IdentityRefWithVote)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestReviewersArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePullRequestStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePullRequestStatus(_a0 context.Context, _a1 git.CreatePullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestStatusArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePush provides a mock function with given fields: _a0, _a1
func (_m *Client) CreatePush(_a0 context.Context, _a1 git.CreatePushArgs) (*git.GitPush, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPush
	if rf, ok := ret.Get(0).(func(context.Context, git.CreatePushArgs) *git.GitPush); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPush)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreatePushArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRepository provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateRepository(_a0 context.Context, _a1 git.CreateRepositoryArgs) (*git.GitRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateRepositoryArgs) *git.GitRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateRepositoryArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRevert provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateRevert(_a0 context.Context, _a1 git.CreateRevertArgs) (*git.GitRevert, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRevert
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateRevertArgs) *git.GitRevert); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRevert)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateRevertArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateThread provides a mock function with given fields: _a0, _a1
func (_m *Client) CreateThread(_a0 context.Context, _a1 git.CreateThreadArgs) (*git.GitPullRequestCommentThread, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestCommentThread
	if rf, ok := ret.Get(0).(func(context.Context, git.CreateThreadArgs) *git.GitPullRequestCommentThread); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestCommentThread)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.CreateThreadArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAttachment provides a mock function with given fields: _a0, _a1
func (_m *Client) DeleteAttachment(_a0 context.Context, _a1 git.DeleteAttachmentArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeleteComment provides a mock function with given fields: _a0, _a1
func (_m *Client) DeleteComment(_a0 context.Context, _a1 git.DeleteCommentArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeleteLike provides a mock function with given fields: _a0, _a1
func (_m *Client) DeleteLike(_a0 context.Context, _a1 git.DeleteLikeArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeletePullRequestIterationStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) DeletePullRequestIterationStatus(_a0 context.Context, _a1 git.DeletePullRequestIterationStatusArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeletePullRequestLabels provides a mock function with given fields: _a0, _a1
func (_m *Client) DeletePullRequestLabels(_a0 context.Context, _a1 git.DeletePullRequestLabelsArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeletePullRequestReviewer provides a mock function with given fields: _a0, _a1
func (_m *Client) DeletePullRequestReviewer(_a0 context.Context, _a1 git.DeletePullRequestReviewerArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeletePullRequestStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) DeletePullRequestStatus(_a0 context.Context, _a1 git.DeletePullRequestStatusArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeleteRefFavorite provides a mock function with given fields: _a0, _a1
func (_m *Client) DeleteRefFavorite(_a0 context.Context, _a1 git.DeleteRefFavoriteArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeleteRepository provides a mock function with given fields: _a0, _a1
func (_m *Client) DeleteRepository(_a0 context.Context, _a1 git.DeleteRepositoryArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DeleteRepositoryFromRecycleBin provides a mock function with given fields: _a0, _a1
func (_m *Client) DeleteRepositoryFromRecycleBin(_a0 context.Context, _a1 git.DeleteRepositoryFromRecycleBinArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// GetAnnotatedTag provides a mock function with given fields: _a0, _a1
func (_m *Client) GetAnnotatedTag(_a0 context.Context, _a1 git.GetAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitAnnotatedTag
	if rf, ok := ret.Get(0).(func(context.Context, git.GetAnnotatedTagArgs) *git.GitAnnotatedTag); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitAnnotatedTag)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetAnnotatedTagArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAttachmentContent provides a mock function with given fields: _a0, _a1
func (_m *Client) GetAttachmentContent(_a0 context.Context, _a1 git.GetAttachmentContentArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetAttachmentContentArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetAttachmentContentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAttachmentZip provides a mock function with given fields: _a0, _a1
func (_m *Client) GetAttachmentZip(_a0 context.Context, _a1 git.GetAttachmentZipArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetAttachmentZipArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetAttachmentZipArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAttachments provides a mock function with given fields: _a0, _a1
func (_m *Client) GetAttachments(_a0 context.Context, _a1 git.GetAttachmentsArgs) (*[]git.Attachment, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.Attachment
	if rf, ok := ret.Get(0).(func(context.Context, git.GetAttachmentsArgs) *[]git.Attachment); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.Attachment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetAttachmentsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlob provides a mock function with given fields: _a0, _a1
func (_m *Client) GetBlob(_a0 context.Context, _a1 git.GetBlobArgs) (*git.GitBlobRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitBlobRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetBlobArgs) *git.GitBlobRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitBlobRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetBlobArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlobContent provides a mock function with given fields: _a0, _a1
func (_m *Client) GetBlobContent(_a0 context.Context, _a1 git.GetBlobContentArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetBlobContentArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetBlobContentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlobZip provides a mock function with given fields: _a0, _a1
func (_m *Client) GetBlobZip(_a0 context.Context, _a1 git.GetBlobZipArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetBlobZipArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetBlobZipArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlobsZip provides a mock function with given fields: _a0, _a1
func (_m *Client) GetBlobsZip(_a0 context.Context, _a1 git.GetBlobsZipArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetBlobsZipArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetBlobsZipArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBranch provides a mock function with given fields: _a0, _a1
func (_m *Client) GetBranch(_a0 context.Context, _a1 git.GetBranchArgs) (*git.GitBranchStats, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitBranchStats
	if rf, ok := ret.Get(0).(func(context.Context, git.GetBranchArgs) *git.GitBranchStats); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitBranchStats)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetBranchArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBranches provides a mock function with given fields: _a0, _a1
func (_m *Client) GetBranches(_a0 context.Context, _a1 git.GetBranchesArgs) (*[]git.GitBranchStats, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitBranchStats
	if rf, ok := ret.Get(0).(func(context.Context, git.GetBranchesArgs) *[]git.GitBranchStats); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitBranchStats)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetBranchesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetChanges provides a mock function with given fields: _a0, _a1
func (_m *Client) GetChanges(_a0 context.Context, _a1 git.GetChangesArgs) (*git.GitCommitChanges, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitCommitChanges
	if rf, ok := ret.Get(0).(func(context.Context, git.GetChangesArgs) *git.GitCommitChanges); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCommitChanges)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetChangesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCherryPick provides a mock function with given fields: _a0, _a1
func (_m *Client) GetCherryPick(_a0 context.Context, _a1 git.GetCherryPickArgs) (*git.GitCherryPick, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitCherryPick
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCherryPickArgs) *git.GitCherryPick); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCherryPick)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCherryPickArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCherryPickForRefName provides a mock function with given fields: _a0, _a1
func (_m *Client) GetCherryPickForRefName(_a0 context.Context, _a1 git.GetCherryPickForRefNameArgs) (*git.GitCherryPick, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitCherryPick
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCherryPickForRefNameArgs) *git.GitCherryPick); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCherryPick)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCherryPickForRefNameArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetComment provides a mock function with given fields: _a0, _a1
func (_m *Client) GetComment(_a0 context.Context, _a1 git.GetCommentArgs) (*git.Comment, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.Comment
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCommentArgs) *git.Comment); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Comment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCommentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetComments provides a mock function with given fields: _a0, _a1
func (_m *Client) GetComments(_a0 context.Context, _a1 git.GetCommentsArgs) (*[]git.Comment, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.Comment
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCommentsArgs) *[]git.Comment); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.Comment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCommentsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCommit provides a mock function with given fields: _a0, _a1
func (_m *Client) GetCommit(_a0 context.Context, _a1 git.GetCommitArgs) (*git.GitCommit, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitCommit
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCommitArgs) *git.GitCommit); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCommit)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCommitArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCommitDiffs provides a mock function with given fields: _a0, _a1
func (_m *Client) GetCommitDiffs(_a0 context.Context, _a1 git.GetCommitDiffsArgs) (*git.GitCommitDiffs, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitCommitDiffs
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCommitDiffsArgs) *git.GitCommitDiffs); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCommitDiffs)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCommitDiffsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCommits provides a mock function with given fields: _a0, _a1
func (_m *Client) GetCommits(_a0 context.Context, _a1 git.GetCommitsArgs) (*[]git.GitCommitRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitCommitRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCommitsArgs) *[]git.GitCommitRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCommitsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCommitsBatch provides a mock function with given fields: _a0, _a1
func (_m *Client) GetCommitsBatch(_a0 context.Context, _a1 git.GetCommitsBatchArgs) (*[]git.GitCommitRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitCommitRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetCommitsBatchArgs) *[]git.GitCommitRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetCommitsBatchArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDeletedRepositories provides a mock function with given fields: _a0, _a1
func (_m *Client) GetDeletedRepositories(_a0 context.Context, _a1 git.GetDeletedRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitDeletedRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.GetDeletedRepositoriesArgs) *[]git.GitDeletedRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitDeletedRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetDeletedRepositoriesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetForkSyncRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) GetForkSyncRequest(_a0 context.Context, _a1 git.GetForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitForkSyncRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetForkSyncRequestArgs) *git.GitForkSyncRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitForkSyncRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetForkSyncRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetForkSyncRequests provides a mock function with given fields: _a0, _a1
func (_m *Client) GetForkSyncRequests(_a0 context.Context, _a1 git.GetForkSyncRequestsArgs) (*[]git.GitForkSyncRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitForkSyncRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetForkSyncRequestsArgs) *[]git.GitForkSyncRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitForkSyncRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetForkSyncRequestsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetForks provides a mock function with given fields: _a0, _a1
func (_m *Client) GetForks(_a0 context.Context, _a1 git.GetForksArgs) (*[]git.GitRepositoryRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitRepositoryRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetForksArgs) *[]git.GitRepositoryRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRepositoryRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetForksArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetImportRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) GetImportRequest(_a0 context.Context, _a1 git.GetImportRequestArgs) (*git.GitImportRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitImportRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetImportRequestArgs) *git.GitImportRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitImportRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetImportRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItem provides a mock function with given fields: _a0, _a1
func (_m *Client) GetItem(_a0 context.Context, _a1 git.GetItemArgs) (*git.GitItem, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitItem
	if rf, ok := ret.Get(0).(func(context.Context, git.GetItemArgs) *git.GitItem); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitItem)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetItemArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItemContent provides a mock function with given fields: _a0, _a1
func (_m *Client) GetItemContent(_a0 context.Context, _a1 git.GetItemContentArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetItemContentArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetItemContentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItemText provides a mock function with given fields: _a0, _a1
func (_m *Client) GetItemText(_a0 context.Context, _a1 git.GetItemTextArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetItemTextArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetItemTextArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItemZip provides a mock function with given fields: _a0, _a1
func (_m *Client) GetItemZip(_a0 context.Context, _a1 git.GetItemZipArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetItemZipArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetItemZipArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItems provides a mock function with given fields: _a0, _a1
func (_m *Client) GetItems(_a0 context.Context, _a1 git.GetItemsArgs) (*[]git.GitItem, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitItem
	if rf, ok := ret.Get(0).(func(context.Context, git.GetItemsArgs) *[]git.GitItem); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitItem)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetItemsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItemsBatch provides a mock function with given fields: _a0, _a1
func (_m *Client) GetItemsBatch(_a0 context.Context, _a1 git.GetItemsBatchArgs) (*[][]git.GitItem, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[][]git.GitItem
	if rf, ok := ret.Get(0).(func(context.Context, git.GetItemsBatchArgs) *[][]git.GitItem); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[][]git.GitItem)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetItemsBatchArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLikes provides a mock function with given fields: _a0, _a1
func (_m *Client) GetLikes(_a0 context.Context, _a1 git.GetLikesArgs) (*[]webapi.IdentityRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]webapi.IdentityRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetLikesArgs) *[]webapi.IdentityRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]webapi.IdentityRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetLikesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetMergeBases provides a mock function with given fields: _a0, _a1
func (_m *Client) GetMergeBases(_a0 context.Context, _a1 git.GetMergeBasesArgs) (*[]git.GitCommitRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitCommitRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetMergeBasesArgs) *[]git.GitCommitRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetMergeBasesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetMergeRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) GetMergeRequest(_a0 context.Context, _a1 git.GetMergeRequestArgs) (*git.GitMerge, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitMerge
	if rf, ok := ret.Get(0).(func(context.Context, git.GetMergeRequestArgs) *git.GitMerge); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitMerge)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetMergeRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicyConfigurations provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPolicyConfigurations(_a0 context.Context, _a1 git.GetPolicyConfigurationsArgs) (*git.GitPolicyConfigurationResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPolicyConfigurationResponse
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPolicyConfigurationsArgs) *git.GitPolicyConfigurationResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPolicyConfigurationResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPolicyConfigurationsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequest(_a0 context.Context, _a1 git.GetPullRequestArgs) (*git.GitPullRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestArgs) *git.GitPullRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestById provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestById(_a0 context.Context, _a1 git.GetPullRequestByIdArgs) (*git.GitPullRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestByIdArgs) *git.GitPullRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestByIdArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestCommits provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestCommits(_a0 context.Context, _a1 git.GetPullRequestCommitsArgs) (*git.GetPullRequestCommitsResponseValue, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GetPullRequestCommitsResponseValue
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestCommitsArgs) *git.GetPullRequestCommitsResponseValue); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GetPullRequestCommitsResponseValue)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestCommitsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestIteration provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestIteration(_a0 context.Context, _a1 git.GetPullRequestIterationArgs) (*git.GitPullRequestIteration, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestIteration
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationArgs) *git.GitPullRequestIteration); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestIteration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestIterationChanges provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestIterationChanges(_a0 context.Context, _a1 git.GetPullRequestIterationChangesArgs) (*git.GitPullRequestIterationChanges, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestIterationChanges
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationChangesArgs) *git.GitPullRequestIterationChanges); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestIterationChanges)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationChangesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestIterationCommits provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestIterationCommits(_a0 context.Context, _a1 git.GetPullRequestIterationCommitsArgs) (*[]git.GitCommitRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitCommitRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationCommitsArgs) *[]git.GitCommitRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationCommitsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestIterationStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestIterationStatus(_a0 context.Context, _a1 git.GetPullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationStatusArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestIterationStatuses provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestIterationStatuses(_a0 context.Context, _a1 git.GetPullRequestIterationStatusesArgs) (*[]git.GitPullRequestStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPullRequestStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationStatusesArgs) *[]git.GitPullRequestStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationStatusesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestIterations provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestIterations(_a0 context.Context, _a1 git.GetPullRequestIterationsArgs) (*[]git.GitPullRequestIteration, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPullRequestIteration
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationsArgs) *[]git.GitPullRequestIteration); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestIteration)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestLabel provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestLabel(_a0 context.Context, _a1 git.GetPullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *core.WebApiTagDefinition
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestLabelArgs) *core.WebApiTagDefinition); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*core.WebApiTagDefinition)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestLabelArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestLabels provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestLabels(_a0 context.Context, _a1 git.GetPullRequestLabelsArgs) (*[]core.WebApiTagDefinition, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]core.WebApiTagDefinition
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestLabelsArgs) *[]core.WebApiTagDefinition); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]core.WebApiTagDefinition)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestLabelsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestProperties provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestProperties(_a0 context.Context, _a1 git.GetPullRequestPropertiesArgs) (interface{}, error) {
	ret := _m.Called(_a0, _a1)

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestPropertiesArgs) interface{}); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestPropertiesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestQuery provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestQuery(_a0 context.Context, _a1 git.GetPullRequestQueryArgs) (*git.GitPullRequestQuery, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestQuery
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestQueryArgs) *git.GitPullRequestQuery); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestQuery)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestQueryArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestReviewer provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestReviewer(_a0 context.Context, _a1 git.GetPullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.IdentityRefWithVote
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestReviewerArgs) *git.IdentityRefWithVote); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.IdentityRefWithVote)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestReviewerArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestReviewers provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestReviewers(_a0 context.Context, _a1 git.GetPullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.IdentityRefWithVote
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestReviewersArgs) *[]git.IdentityRefWithVote); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.IdentityRefWithVote)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestReviewersArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestStatus provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestStatus(_a0 context.Context, _a1 git.GetPullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestStatusArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestStatuses provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestStatuses(_a0 context.Context, _a1 git.GetPullRequestStatusesArgs) (*[]git.GitPullRequestStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPullRequestStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestStatusesArgs) *[]git.GitPullRequestStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestStatusesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestThread provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestThread(_a0 context.Context, _a1 git.GetPullRequestThreadArgs) (*git.GitPullRequestCommentThread, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestCommentThread
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestThreadArgs) *git.GitPullRequestCommentThread); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestCommentThread)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestThreadArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestWorkItemRefs provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestWorkItemRefs(_a0 context.Context, _a1 git.GetPullRequestWorkItemRefsArgs) (*[]webapi.ResourceRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]webapi.ResourceRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestWorkItemRefsArgs) *[]webapi.ResourceRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]webapi.ResourceRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestWorkItemRefsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequests provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequests(_a0 context.Context, _a1 git.GetPullRequestsArgs) (*[]git.GitPullRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPullRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestsArgs) *[]git.GitPullRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPullRequestsByProject provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPullRequestsByProject(_a0 context.Context, _a1 git.GetPullRequestsByProjectArgs) (*[]git.GitPullRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPullRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPullRequestsByProjectArgs) *[]git.GitPullRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPullRequestsByProjectArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPush provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPush(_a0 context.Context, _a1 git.GetPushArgs) (*git.GitPush, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPush
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPushArgs) *git.GitPush); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPush)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPushArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPushCommits provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPushCommits(_a0 context.Context, _a1 git.GetPushCommitsArgs) (*[]git.GitCommitRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitCommitRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPushCommitsArgs) *[]git.GitCommitRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPushCommitsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPushes provides a mock function with given fields: _a0, _a1
func (_m *Client) GetPushes(_a0 context.Context, _a1 git.GetPushesArgs) (*[]git.GitPush, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPush
	if rf, ok := ret.Get(0).(func(context.Context, git.GetPushesArgs) *[]git.GitPush); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPush)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetPushesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRecycleBinRepositories provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRecycleBinRepositories(_a0 context.Context, _a1 git.GetRecycleBinRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitDeletedRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRecycleBinRepositoriesArgs) *[]git.GitDeletedRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitDeletedRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRecycleBinRepositoriesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRefFavorite provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRefFavorite(_a0 context.Context, _a1 git.GetRefFavoriteArgs) (*git.GitRefFavorite, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRefFavorite
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRefFavoriteArgs) *git.GitRefFavorite); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRefFavorite)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRefFavoriteArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRefFavorites provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRefFavorites(_a0 context.Context, _a1 git.GetRefFavoritesArgs) (*[]git.GitRefFavorite, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitRefFavorite
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRefFavoritesArgs) *[]git.GitRefFavorite); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRefFavorite)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRefFavoritesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRefs provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRefs(_a0 context.Context, _a1 git.GetRefsArgs) (*git.GetRefsResponseValue, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GetRefsResponseValue
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRefsArgs) *git.GetRefsResponseValue); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GetRefsResponseValue)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRefsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepositories provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRepositories(_a0 context.Context, _a1 git.GetRepositoriesArgs) (*[]git.GitRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRepositoriesArgs) *[]git.GitRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRepositoriesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepository provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRepository(_a0 context.Context, _a1 git.GetRepositoryArgs) (*git.GitRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRepositoryArgs) *git.GitRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRepositoryArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepositoryWithParent provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRepositoryWithParent(_a0 context.Context, _a1 git.GetRepositoryWithParentArgs) (*git.GitRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRepositoryWithParentArgs) *git.GitRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRepositoryWithParentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRevert provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRevert(_a0 context.Context, _a1 git.GetRevertArgs) (*git.GitRevert, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRevert
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRevertArgs) *git.GitRevert); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRevert)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRevertArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRevertForRefName provides a mock function with given fields: _a0, _a1
func (_m *Client) GetRevertForRefName(_a0 context.Context, _a1 git.GetRevertForRefNameArgs) (*git.GitRevert, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRevert
	if rf, ok := ret.Get(0).(func(context.Context, git.GetRevertForRefNameArgs) *git.GitRevert); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRevert)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetRevertForRefNameArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetStatuses provides a mock function with given fields: _a0, _a1
func (_m *Client) GetStatuses(_a0 context.Context, _a1 git.GetStatusesArgs) (*[]git.GitStatus, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitStatus
	if rf, ok := ret.Get(0).(func(context.Context, git.GetStatusesArgs) *[]git.GitStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitStatus)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetStatusesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSuggestions provides a mock function with given fields: _a0, _a1
func (_m *Client) GetSuggestions(_a0 context.Context, _a1 git.GetSuggestionsArgs) (*[]git.GitSuggestion, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitSuggestion
	if rf, ok := ret.Get(0).(func(context.Context, git.GetSuggestionsArgs) *[]git.GitSuggestion); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitSuggestion)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetSuggestionsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetThreads provides a mock function with given fields: _a0, _a1
func (_m *Client) GetThreads(_a0 context.Context, _a1 git.GetThreadsArgs) (*[]git.GitPullRequestCommentThread, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitPullRequestCommentThread
	if rf, ok := ret.Get(0).(func(context.Context, git.GetThreadsArgs) *[]git.GitPullRequestCommentThread); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestCommentThread)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetThreadsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTree provides a mock function with given fields: _a0, _a1
func (_m *Client) GetTree(_a0 context.Context, _a1 git.GetTreeArgs) (*git.GitTreeRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitTreeRef
	if rf, ok := ret.Get(0).(func(context.Context, git.GetTreeArgs) *git.GitTreeRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitTreeRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetTreeArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTreeZip provides a mock function with given fields: _a0, _a1
func (_m *Client) GetTreeZip(_a0 context.Context, _a1 git.GetTreeZipArgs) (io.ReadCloser, error) {
	ret := _m.Called(_a0, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, git.GetTreeZipArgs) io.ReadCloser); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.GetTreeZipArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QueryImportRequests provides a mock function with given fields: _a0, _a1
func (_m *Client) QueryImportRequests(_a0 context.Context, _a1 git.QueryImportRequestsArgs) (*[]git.GitImportRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitImportRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.QueryImportRequestsArgs) *[]git.GitImportRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitImportRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.QueryImportRequestsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreRepositoryFromRecycleBin provides a mock function with given fields: _a0, _a1
func (_m *Client) RestoreRepositoryFromRecycleBin(_a0 context.Context, _a1 git.RestoreRepositoryFromRecycleBinArgs) (*git.GitRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.RestoreRepositoryFromRecycleBinArgs) *git.GitRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.RestoreRepositoryFromRecycleBinArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SharePullRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) SharePullRequest(_a0 context.Context, _a1 git.SharePullRequestArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// UpdateComment provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdateComment(_a0 context.Context, _a1 git.UpdateCommentArgs) (*git.Comment, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.Comment
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdateCommentArgs) *git.Comment); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Comment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdateCommentArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateImportRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdateImportRequest(_a0 context.Context, _a1 git.UpdateImportRequestArgs) (*git.GitImportRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitImportRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdateImportRequestArgs) *git.GitImportRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitImportRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdateImportRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePullRequest provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdatePullRequest(_a0 context.Context, _a1 git.UpdatePullRequestArgs) (*git.GitPullRequest, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequest
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestArgs) *git.GitPullRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdatePullRequestArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePullRequestIterationStatuses provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdatePullRequestIterationStatuses(_a0 context.Context, _a1 git.UpdatePullRequestIterationStatusesArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// UpdatePullRequestProperties provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdatePullRequestProperties(_a0 context.Context, _a1 git.UpdatePullRequestPropertiesArgs) (interface{}, error) {
	ret := _m.Called(_a0, _a1)

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestPropertiesArgs) interface{}); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdatePullRequestPropertiesArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdatePullRequestReviewers provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdatePullRequestReviewers(_a0 context.Context, _a1 git.UpdatePullRequestReviewersArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// UpdatePullRequestStatuses provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdatePullRequestStatuses(_a0 context.Context, _a1 git.UpdatePullRequestStatusesArgs) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// UpdateRef provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdateRef(_a0 context.Context, _a1 git.UpdateRefArgs) (*git.GitRef, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRef
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdateRefArgs) *git.GitRef); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRef)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdateRefArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRefs provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdateRefs(_a0 context.Context, _a1 git.UpdateRefsArgs) (*[]git.GitRefUpdateResult, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *[]git.GitRefUpdateResult
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdateRefsArgs) *[]git.GitRefUpdateResult); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRefUpdateResult)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdateRefsArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRepository provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdateRepository(_a0 context.Context, _a1 git.UpdateRepositoryArgs) (*git.GitRepository, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitRepository
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdateRepositoryArgs) *git.GitRepository); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdateRepositoryArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateThread provides a mock function with given fields: _a0, _a1
func (_m *Client) UpdateThread(_a0 context.Context, _a1 git.UpdateThreadArgs) (*git.GitPullRequestCommentThread, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *git.GitPullRequestCommentThread
	if rf, ok := ret.Get(0).(func(context.Context, git.UpdateThreadArgs) *git.GitPullRequestCommentThread); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestCommentThread)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, git.UpdateThreadArgs) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
