// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"
	"io"

	"github.com/microsoft/azure-devops-go-api/azuredevops/v7/core"
	"github.com/microsoft/azure-devops-go-api/azuredevops/v7/git"
	"github.com/microsoft/azure-devops-go-api/azuredevops/v7/webapi"
	mock "github.com/stretchr/testify/mock"
)

// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *Client {
	mock := &Client{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type Client_Expecter struct {
	mock *mock.Mock
}

func (_m *Client) EXPECT() *Client_Expecter {
	return &Client_Expecter{mock: &_m.Mock}
}

// CreateAnnotatedTag provides a mock function for the type Client
func (_mock *Client) CreateAnnotatedTag(context1 context.Context, createAnnotatedTagArgs git.CreateAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
	ret := _mock.Called(context1, createAnnotatedTagArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateAnnotatedTag")
	}

	var r0 *git.GitAnnotatedTag
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateAnnotatedTagArgs) (*git.GitAnnotatedTag, error)); ok {
		return returnFunc(context1, createAnnotatedTagArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateAnnotatedTagArgs) *git.GitAnnotatedTag); ok {
		r0 = returnFunc(context1, createAnnotatedTagArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitAnnotatedTag)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateAnnotatedTagArgs) error); ok {
		r1 = returnFunc(context1, createAnnotatedTagArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateAnnotatedTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAnnotatedTag'
type Client_CreateAnnotatedTag_Call struct {
	*mock.Call
}

// CreateAnnotatedTag is a helper method to define mock.On call
//   - context1 context.Context
//   - createAnnotatedTagArgs git.CreateAnnotatedTagArgs
func (_e *Client_Expecter) CreateAnnotatedTag(context1 interface{}, createAnnotatedTagArgs interface{}) *Client_CreateAnnotatedTag_Call {
	return &Client_CreateAnnotatedTag_Call{Call: _e.mock.On("CreateAnnotatedTag", context1, createAnnotatedTagArgs)}
}

func (_c *Client_CreateAnnotatedTag_Call) Run(run func(context1 context.Context, createAnnotatedTagArgs git.CreateAnnotatedTagArgs)) *Client_CreateAnnotatedTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateAnnotatedTagArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateAnnotatedTagArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateAnnotatedTag_Call) Return(gitAnnotatedTag *git.GitAnnotatedTag, err error) *Client_CreateAnnotatedTag_Call {
	_c.Call.Return(gitAnnotatedTag, err)
	return _c
}

func (_c *Client_CreateAnnotatedTag_Call) RunAndReturn(run func(context1 context.Context, createAnnotatedTagArgs git.CreateAnnotatedTagArgs) (*git.GitAnnotatedTag, error)) *Client_CreateAnnotatedTag_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAttachment provides a mock function for the type Client
func (_mock *Client) CreateAttachment(context1 context.Context, createAttachmentArgs git.CreateAttachmentArgs) (*git.Attachment, error) {
	ret := _mock.Called(context1, createAttachmentArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateAttachment")
	}

	var r0 *git.Attachment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateAttachmentArgs) (*git.Attachment, error)); ok {
		return returnFunc(context1, createAttachmentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateAttachmentArgs) *git.Attachment); ok {
		r0 = returnFunc(context1, createAttachmentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Attachment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateAttachmentArgs) error); ok {
		r1 = returnFunc(context1, createAttachmentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAttachment'
type Client_CreateAttachment_Call struct {
	*mock.Call
}

// CreateAttachment is a helper method to define mock.On call
//   - context1 context.Context
//   - createAttachmentArgs git.CreateAttachmentArgs
func (_e *Client_Expecter) CreateAttachment(context1 interface{}, createAttachmentArgs interface{}) *Client_CreateAttachment_Call {
	return &Client_CreateAttachment_Call{Call: _e.mock.On("CreateAttachment", context1, createAttachmentArgs)}
}

func (_c *Client_CreateAttachment_Call) Run(run func(context1 context.Context, createAttachmentArgs git.CreateAttachmentArgs)) *Client_CreateAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateAttachmentArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateAttachmentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateAttachment_Call) Return(attachment *git.Attachment, err error) *Client_CreateAttachment_Call {
	_c.Call.Return(attachment, err)
	return _c
}

func (_c *Client_CreateAttachment_Call) RunAndReturn(run func(context1 context.Context, createAttachmentArgs git.CreateAttachmentArgs) (*git.Attachment, error)) *Client_CreateAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCherryPick provides a mock function for the type Client
func (_mock *Client) CreateCherryPick(context1 context.Context, createCherryPickArgs git.CreateCherryPickArgs) (*git.GitCherryPick, error) {
	ret := _mock.Called(context1, createCherryPickArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateCherryPick")
	}

	var r0 *git.GitCherryPick
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateCherryPickArgs) (*git.GitCherryPick, error)); ok {
		return returnFunc(context1, createCherryPickArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateCherryPickArgs) *git.GitCherryPick); ok {
		r0 = returnFunc(context1, createCherryPickArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCherryPick)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateCherryPickArgs) error); ok {
		r1 = returnFunc(context1, createCherryPickArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateCherryPick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCherryPick'
type Client_CreateCherryPick_Call struct {
	*mock.Call
}

// CreateCherryPick is a helper method to define mock.On call
//   - context1 context.Context
//   - createCherryPickArgs git.CreateCherryPickArgs
func (_e *Client_Expecter) CreateCherryPick(context1 interface{}, createCherryPickArgs interface{}) *Client_CreateCherryPick_Call {
	return &Client_CreateCherryPick_Call{Call: _e.mock.On("CreateCherryPick", context1, createCherryPickArgs)}
}

func (_c *Client_CreateCherryPick_Call) Run(run func(context1 context.Context, createCherryPickArgs git.CreateCherryPickArgs)) *Client_CreateCherryPick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateCherryPickArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateCherryPickArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateCherryPick_Call) Return(gitCherryPick *git.GitCherryPick, err error) *Client_CreateCherryPick_Call {
	_c.Call.Return(gitCherryPick, err)
	return _c
}

func (_c *Client_CreateCherryPick_Call) RunAndReturn(run func(context1 context.Context, createCherryPickArgs git.CreateCherryPickArgs) (*git.GitCherryPick, error)) *Client_CreateCherryPick_Call {
	_c.Call.Return(run)
	return _c
}

// CreateComment provides a mock function for the type Client
func (_mock *Client) CreateComment(context1 context.Context, createCommentArgs git.CreateCommentArgs) (*git.Comment, error) {
	ret := _mock.Called(context1, createCommentArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateComment")
	}

	var r0 *git.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateCommentArgs) (*git.Comment, error)); ok {
		return returnFunc(context1, createCommentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateCommentArgs) *git.Comment); ok {
		r0 = returnFunc(context1, createCommentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Comment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateCommentArgs) error); ok {
		r1 = returnFunc(context1, createCommentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateComment'
type Client_CreateComment_Call struct {
	*mock.Call
}

// CreateComment is a helper method to define mock.On call
//   - context1 context.Context
//   - createCommentArgs git.CreateCommentArgs
func (_e *Client_Expecter) CreateComment(context1 interface{}, createCommentArgs interface{}) *Client_CreateComment_Call {
	return &Client_CreateComment_Call{Call: _e.mock.On("CreateComment", context1, createCommentArgs)}
}

func (_c *Client_CreateComment_Call) Run(run func(context1 context.Context, createCommentArgs git.CreateCommentArgs)) *Client_CreateComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateCommentArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateCommentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateComment_Call) Return(comment *git.Comment, err error) *Client_CreateComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *Client_CreateComment_Call) RunAndReturn(run func(context1 context.Context, createCommentArgs git.CreateCommentArgs) (*git.Comment, error)) *Client_CreateComment_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCommitStatus provides a mock function for the type Client
func (_mock *Client) CreateCommitStatus(context1 context.Context, createCommitStatusArgs git.CreateCommitStatusArgs) (*git.GitStatus, error) {
	ret := _mock.Called(context1, createCommitStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateCommitStatus")
	}

	var r0 *git.GitStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateCommitStatusArgs) (*git.GitStatus, error)); ok {
		return returnFunc(context1, createCommitStatusArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateCommitStatusArgs) *git.GitStatus); ok {
		r0 = returnFunc(context1, createCommitStatusArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateCommitStatusArgs) error); ok {
		r1 = returnFunc(context1, createCommitStatusArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateCommitStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCommitStatus'
type Client_CreateCommitStatus_Call struct {
	*mock.Call
}

// CreateCommitStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - createCommitStatusArgs git.CreateCommitStatusArgs
func (_e *Client_Expecter) CreateCommitStatus(context1 interface{}, createCommitStatusArgs interface{}) *Client_CreateCommitStatus_Call {
	return &Client_CreateCommitStatus_Call{Call: _e.mock.On("CreateCommitStatus", context1, createCommitStatusArgs)}
}

func (_c *Client_CreateCommitStatus_Call) Run(run func(context1 context.Context, createCommitStatusArgs git.CreateCommitStatusArgs)) *Client_CreateCommitStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateCommitStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateCommitStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateCommitStatus_Call) Return(gitStatus *git.GitStatus, err error) *Client_CreateCommitStatus_Call {
	_c.Call.Return(gitStatus, err)
	return _c
}

func (_c *Client_CreateCommitStatus_Call) RunAndReturn(run func(context1 context.Context, createCommitStatusArgs git.CreateCommitStatusArgs) (*git.GitStatus, error)) *Client_CreateCommitStatus_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFavorite provides a mock function for the type Client
func (_mock *Client) CreateFavorite(context1 context.Context, createFavoriteArgs git.CreateFavoriteArgs) (*git.GitRefFavorite, error) {
	ret := _mock.Called(context1, createFavoriteArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateFavorite")
	}

	var r0 *git.GitRefFavorite
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateFavoriteArgs) (*git.GitRefFavorite, error)); ok {
		return returnFunc(context1, createFavoriteArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateFavoriteArgs) *git.GitRefFavorite); ok {
		r0 = returnFunc(context1, createFavoriteArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRefFavorite)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateFavoriteArgs) error); ok {
		r1 = returnFunc(context1, createFavoriteArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFavorite'
type Client_CreateFavorite_Call struct {
	*mock.Call
}

// CreateFavorite is a helper method to define mock.On call
//   - context1 context.Context
//   - createFavoriteArgs git.CreateFavoriteArgs
func (_e *Client_Expecter) CreateFavorite(context1 interface{}, createFavoriteArgs interface{}) *Client_CreateFavorite_Call {
	return &Client_CreateFavorite_Call{Call: _e.mock.On("CreateFavorite", context1, createFavoriteArgs)}
}

func (_c *Client_CreateFavorite_Call) Run(run func(context1 context.Context, createFavoriteArgs git.CreateFavoriteArgs)) *Client_CreateFavorite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateFavoriteArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateFavoriteArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateFavorite_Call) Return(gitRefFavorite *git.GitRefFavorite, err error) *Client_CreateFavorite_Call {
	_c.Call.Return(gitRefFavorite, err)
	return _c
}

func (_c *Client_CreateFavorite_Call) RunAndReturn(run func(context1 context.Context, createFavoriteArgs git.CreateFavoriteArgs) (*git.GitRefFavorite, error)) *Client_CreateFavorite_Call {
	_c.Call.Return(run)
	return _c
}

// CreateForkSyncRequest provides a mock function for the type Client
func (_mock *Client) CreateForkSyncRequest(context1 context.Context, createForkSyncRequestArgs git.CreateForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
	ret := _mock.Called(context1, createForkSyncRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateForkSyncRequest")
	}

	var r0 *git.GitForkSyncRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateForkSyncRequestArgs) (*git.GitForkSyncRequest, error)); ok {
		return returnFunc(context1, createForkSyncRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateForkSyncRequestArgs) *git.GitForkSyncRequest); ok {
		r0 = returnFunc(context1, createForkSyncRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitForkSyncRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateForkSyncRequestArgs) error); ok {
		r1 = returnFunc(context1, createForkSyncRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateForkSyncRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateForkSyncRequest'
type Client_CreateForkSyncRequest_Call struct {
	*mock.Call
}

// CreateForkSyncRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - createForkSyncRequestArgs git.CreateForkSyncRequestArgs
func (_e *Client_Expecter) CreateForkSyncRequest(context1 interface{}, createForkSyncRequestArgs interface{}) *Client_CreateForkSyncRequest_Call {
	return &Client_CreateForkSyncRequest_Call{Call: _e.mock.On("CreateForkSyncRequest", context1, createForkSyncRequestArgs)}
}

func (_c *Client_CreateForkSyncRequest_Call) Run(run func(context1 context.Context, createForkSyncRequestArgs git.CreateForkSyncRequestArgs)) *Client_CreateForkSyncRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateForkSyncRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateForkSyncRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateForkSyncRequest_Call) Return(gitForkSyncRequest *git.GitForkSyncRequest, err error) *Client_CreateForkSyncRequest_Call {
	_c.Call.Return(gitForkSyncRequest, err)
	return _c
}

func (_c *Client_CreateForkSyncRequest_Call) RunAndReturn(run func(context1 context.Context, createForkSyncRequestArgs git.CreateForkSyncRequestArgs) (*git.GitForkSyncRequest, error)) *Client_CreateForkSyncRequest_Call {
	_c.Call.Return(run)
	return _c
}

// CreateImportRequest provides a mock function for the type Client
func (_mock *Client) CreateImportRequest(context1 context.Context, createImportRequestArgs git.CreateImportRequestArgs) (*git.GitImportRequest, error) {
	ret := _mock.Called(context1, createImportRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateImportRequest")
	}

	var r0 *git.GitImportRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateImportRequestArgs) (*git.GitImportRequest, error)); ok {
		return returnFunc(context1, createImportRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateImportRequestArgs) *git.GitImportRequest); ok {
		r0 = returnFunc(context1, createImportRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitImportRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateImportRequestArgs) error); ok {
		r1 = returnFunc(context1, createImportRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateImportRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateImportRequest'
type Client_CreateImportRequest_Call struct {
	*mock.Call
}

// CreateImportRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - createImportRequestArgs git.CreateImportRequestArgs
func (_e *Client_Expecter) CreateImportRequest(context1 interface{}, createImportRequestArgs interface{}) *Client_CreateImportRequest_Call {
	return &Client_CreateImportRequest_Call{Call: _e.mock.On("CreateImportRequest", context1, createImportRequestArgs)}
}

func (_c *Client_CreateImportRequest_Call) Run(run func(context1 context.Context, createImportRequestArgs git.CreateImportRequestArgs)) *Client_CreateImportRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateImportRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateImportRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateImportRequest_Call) Return(gitImportRequest *git.GitImportRequest, err error) *Client_CreateImportRequest_Call {
	_c.Call.Return(gitImportRequest, err)
	return _c
}

func (_c *Client_CreateImportRequest_Call) RunAndReturn(run func(context1 context.Context, createImportRequestArgs git.CreateImportRequestArgs) (*git.GitImportRequest, error)) *Client_CreateImportRequest_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLike provides a mock function for the type Client
func (_mock *Client) CreateLike(context1 context.Context, createLikeArgs git.CreateLikeArgs) error {
	ret := _mock.Called(context1, createLikeArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateLike")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateLikeArgs) error); ok {
		r0 = returnFunc(context1, createLikeArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_CreateLike_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLike'
type Client_CreateLike_Call struct {
	*mock.Call
}

// CreateLike is a helper method to define mock.On call
//   - context1 context.Context
//   - createLikeArgs git.CreateLikeArgs
func (_e *Client_Expecter) CreateLike(context1 interface{}, createLikeArgs interface{}) *Client_CreateLike_Call {
	return &Client_CreateLike_Call{Call: _e.mock.On("CreateLike", context1, createLikeArgs)}
}

func (_c *Client_CreateLike_Call) Run(run func(context1 context.Context, createLikeArgs git.CreateLikeArgs)) *Client_CreateLike_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateLikeArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateLikeArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateLike_Call) Return(err error) *Client_CreateLike_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_CreateLike_Call) RunAndReturn(run func(context1 context.Context, createLikeArgs git.CreateLikeArgs) error) *Client_CreateLike_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMergeRequest provides a mock function for the type Client
func (_mock *Client) CreateMergeRequest(context1 context.Context, createMergeRequestArgs git.CreateMergeRequestArgs) (*git.GitMerge, error) {
	ret := _mock.Called(context1, createMergeRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateMergeRequest")
	}

	var r0 *git.GitMerge
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateMergeRequestArgs) (*git.GitMerge, error)); ok {
		return returnFunc(context1, createMergeRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateMergeRequestArgs) *git.GitMerge); ok {
		r0 = returnFunc(context1, createMergeRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitMerge)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateMergeRequestArgs) error); ok {
		r1 = returnFunc(context1, createMergeRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateMergeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMergeRequest'
type Client_CreateMergeRequest_Call struct {
	*mock.Call
}

// CreateMergeRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - createMergeRequestArgs git.CreateMergeRequestArgs
func (_e *Client_Expecter) CreateMergeRequest(context1 interface{}, createMergeRequestArgs interface{}) *Client_CreateMergeRequest_Call {
	return &Client_CreateMergeRequest_Call{Call: _e.mock.On("CreateMergeRequest", context1, createMergeRequestArgs)}
}

func (_c *Client_CreateMergeRequest_Call) Run(run func(context1 context.Context, createMergeRequestArgs git.CreateMergeRequestArgs)) *Client_CreateMergeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateMergeRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateMergeRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateMergeRequest_Call) Return(gitMerge *git.GitMerge, err error) *Client_CreateMergeRequest_Call {
	_c.Call.Return(gitMerge, err)
	return _c
}

func (_c *Client_CreateMergeRequest_Call) RunAndReturn(run func(context1 context.Context, createMergeRequestArgs git.CreateMergeRequestArgs) (*git.GitMerge, error)) *Client_CreateMergeRequest_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePullRequest provides a mock function for the type Client
func (_mock *Client) CreatePullRequest(context1 context.Context, createPullRequestArgs git.CreatePullRequestArgs) (*git.GitPullRequest, error) {
	ret := _mock.Called(context1, createPullRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePullRequest")
	}

	var r0 *git.GitPullRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestArgs) (*git.GitPullRequest, error)); ok {
		return returnFunc(context1, createPullRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestArgs) *git.GitPullRequest); ok {
		r0 = returnFunc(context1, createPullRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestArgs) error); ok {
		r1 = returnFunc(context1, createPullRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePullRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequest'
type Client_CreatePullRequest_Call struct {
	*mock.Call
}

// CreatePullRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - createPullRequestArgs git.CreatePullRequestArgs
func (_e *Client_Expecter) CreatePullRequest(context1 interface{}, createPullRequestArgs interface{}) *Client_CreatePullRequest_Call {
	return &Client_CreatePullRequest_Call{Call: _e.mock.On("CreatePullRequest", context1, createPullRequestArgs)}
}

func (_c *Client_CreatePullRequest_Call) Run(run func(context1 context.Context, createPullRequestArgs git.CreatePullRequestArgs)) *Client_CreatePullRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePullRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePullRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePullRequest_Call) Return(gitPullRequest *git.GitPullRequest, err error) *Client_CreatePullRequest_Call {
	_c.Call.Return(gitPullRequest, err)
	return _c
}

func (_c *Client_CreatePullRequest_Call) RunAndReturn(run func(context1 context.Context, createPullRequestArgs git.CreatePullRequestArgs) (*git.GitPullRequest, error)) *Client_CreatePullRequest_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePullRequestIterationStatus provides a mock function for the type Client
func (_mock *Client) CreatePullRequestIterationStatus(context1 context.Context, createPullRequestIterationStatusArgs git.CreatePullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _mock.Called(context1, createPullRequestIterationStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePullRequestIterationStatus")
	}

	var r0 *git.GitPullRequestStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error)); ok {
		return returnFunc(context1, createPullRequestIterationStatusArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestIterationStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = returnFunc(context1, createPullRequestIterationStatusArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestIterationStatusArgs) error); ok {
		r1 = returnFunc(context1, createPullRequestIterationStatusArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePullRequestIterationStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequestIterationStatus'
type Client_CreatePullRequestIterationStatus_Call struct {
	*mock.Call
}

// CreatePullRequestIterationStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - createPullRequestIterationStatusArgs git.CreatePullRequestIterationStatusArgs
func (_e *Client_Expecter) CreatePullRequestIterationStatus(context1 interface{}, createPullRequestIterationStatusArgs interface{}) *Client_CreatePullRequestIterationStatus_Call {
	return &Client_CreatePullRequestIterationStatus_Call{Call: _e.mock.On("CreatePullRequestIterationStatus", context1, createPullRequestIterationStatusArgs)}
}

func (_c *Client_CreatePullRequestIterationStatus_Call) Run(run func(context1 context.Context, createPullRequestIterationStatusArgs git.CreatePullRequestIterationStatusArgs)) *Client_CreatePullRequestIterationStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePullRequestIterationStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePullRequestIterationStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePullRequestIterationStatus_Call) Return(gitPullRequestStatus *git.GitPullRequestStatus, err error) *Client_CreatePullRequestIterationStatus_Call {
	_c.Call.Return(gitPullRequestStatus, err)
	return _c
}

func (_c *Client_CreatePullRequestIterationStatus_Call) RunAndReturn(run func(context1 context.Context, createPullRequestIterationStatusArgs git.CreatePullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error)) *Client_CreatePullRequestIterationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePullRequestLabel provides a mock function for the type Client
func (_mock *Client) CreatePullRequestLabel(context1 context.Context, createPullRequestLabelArgs git.CreatePullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
	ret := _mock.Called(context1, createPullRequestLabelArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePullRequestLabel")
	}

	var r0 *core.WebApiTagDefinition
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestLabelArgs) (*core.WebApiTagDefinition, error)); ok {
		return returnFunc(context1, createPullRequestLabelArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestLabelArgs) *core.WebApiTagDefinition); ok {
		r0 = returnFunc(context1, createPullRequestLabelArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*core.WebApiTagDefinition)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestLabelArgs) error); ok {
		r1 = returnFunc(context1, createPullRequestLabelArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePullRequestLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequestLabel'
type Client_CreatePullRequestLabel_Call struct {
	*mock.Call
}

// CreatePullRequestLabel is a helper method to define mock.On call
//   - context1 context.Context
//   - createPullRequestLabelArgs git.CreatePullRequestLabelArgs
func (_e *Client_Expecter) CreatePullRequestLabel(context1 interface{}, createPullRequestLabelArgs interface{}) *Client_CreatePullRequestLabel_Call {
	return &Client_CreatePullRequestLabel_Call{Call: _e.mock.On("CreatePullRequestLabel", context1, createPullRequestLabelArgs)}
}

func (_c *Client_CreatePullRequestLabel_Call) Run(run func(context1 context.Context, createPullRequestLabelArgs git.CreatePullRequestLabelArgs)) *Client_CreatePullRequestLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePullRequestLabelArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePullRequestLabelArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePullRequestLabel_Call) Return(webApiTagDefinition *core.WebApiTagDefinition, err error) *Client_CreatePullRequestLabel_Call {
	_c.Call.Return(webApiTagDefinition, err)
	return _c
}

func (_c *Client_CreatePullRequestLabel_Call) RunAndReturn(run func(context1 context.Context, createPullRequestLabelArgs git.CreatePullRequestLabelArgs) (*core.WebApiTagDefinition, error)) *Client_CreatePullRequestLabel_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePullRequestReviewer provides a mock function for the type Client
func (_mock *Client) CreatePullRequestReviewer(context1 context.Context, createPullRequestReviewerArgs git.CreatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	ret := _mock.Called(context1, createPullRequestReviewerArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePullRequestReviewer")
	}

	var r0 *git.IdentityRefWithVote
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error)); ok {
		return returnFunc(context1, createPullRequestReviewerArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestReviewerArgs) *git.IdentityRefWithVote); ok {
		r0 = returnFunc(context1, createPullRequestReviewerArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.IdentityRefWithVote)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestReviewerArgs) error); ok {
		r1 = returnFunc(context1, createPullRequestReviewerArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePullRequestReviewer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequestReviewer'
type Client_CreatePullRequestReviewer_Call struct {
	*mock.Call
}

// CreatePullRequestReviewer is a helper method to define mock.On call
//   - context1 context.Context
//   - createPullRequestReviewerArgs git.CreatePullRequestReviewerArgs
func (_e *Client_Expecter) CreatePullRequestReviewer(context1 interface{}, createPullRequestReviewerArgs interface{}) *Client_CreatePullRequestReviewer_Call {
	return &Client_CreatePullRequestReviewer_Call{Call: _e.mock.On("CreatePullRequestReviewer", context1, createPullRequestReviewerArgs)}
}

func (_c *Client_CreatePullRequestReviewer_Call) Run(run func(context1 context.Context, createPullRequestReviewerArgs git.CreatePullRequestReviewerArgs)) *Client_CreatePullRequestReviewer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePullRequestReviewerArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePullRequestReviewerArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePullRequestReviewer_Call) Return(identityRefWithVote *git.IdentityRefWithVote, err error) *Client_CreatePullRequestReviewer_Call {
	_c.Call.Return(identityRefWithVote, err)
	return _c
}

func (_c *Client_CreatePullRequestReviewer_Call) RunAndReturn(run func(context1 context.Context, createPullRequestReviewerArgs git.CreatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error)) *Client_CreatePullRequestReviewer_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePullRequestReviewers provides a mock function for the type Client
func (_mock *Client) CreatePullRequestReviewers(context1 context.Context, createPullRequestReviewersArgs git.CreatePullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
	ret := _mock.Called(context1, createPullRequestReviewersArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePullRequestReviewers")
	}

	var r0 *[]git.IdentityRefWithVote
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error)); ok {
		return returnFunc(context1, createPullRequestReviewersArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestReviewersArgs) *[]git.IdentityRefWithVote); ok {
		r0 = returnFunc(context1, createPullRequestReviewersArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.IdentityRefWithVote)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestReviewersArgs) error); ok {
		r1 = returnFunc(context1, createPullRequestReviewersArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePullRequestReviewers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequestReviewers'
type Client_CreatePullRequestReviewers_Call struct {
	*mock.Call
}

// CreatePullRequestReviewers is a helper method to define mock.On call
//   - context1 context.Context
//   - createPullRequestReviewersArgs git.CreatePullRequestReviewersArgs
func (_e *Client_Expecter) CreatePullRequestReviewers(context1 interface{}, createPullRequestReviewersArgs interface{}) *Client_CreatePullRequestReviewers_Call {
	return &Client_CreatePullRequestReviewers_Call{Call: _e.mock.On("CreatePullRequestReviewers", context1, createPullRequestReviewersArgs)}
}

func (_c *Client_CreatePullRequestReviewers_Call) Run(run func(context1 context.Context, createPullRequestReviewersArgs git.CreatePullRequestReviewersArgs)) *Client_CreatePullRequestReviewers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePullRequestReviewersArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePullRequestReviewersArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePullRequestReviewers_Call) Return(identityRefWithVotes *[]git.IdentityRefWithVote, err error) *Client_CreatePullRequestReviewers_Call {
	_c.Call.Return(identityRefWithVotes, err)
	return _c
}

func (_c *Client_CreatePullRequestReviewers_Call) RunAndReturn(run func(context1 context.Context, createPullRequestReviewersArgs git.CreatePullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error)) *Client_CreatePullRequestReviewers_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePullRequestStatus provides a mock function for the type Client
func (_mock *Client) CreatePullRequestStatus(context1 context.Context, createPullRequestStatusArgs git.CreatePullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _mock.Called(context1, createPullRequestStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePullRequestStatus")
	}

	var r0 *git.GitPullRequestStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestStatusArgs) (*git.GitPullRequestStatus, error)); ok {
		return returnFunc(context1, createPullRequestStatusArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePullRequestStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = returnFunc(context1, createPullRequestStatusArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePullRequestStatusArgs) error); ok {
		r1 = returnFunc(context1, createPullRequestStatusArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePullRequestStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequestStatus'
type Client_CreatePullRequestStatus_Call struct {
	*mock.Call
}

// CreatePullRequestStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - createPullRequestStatusArgs git.CreatePullRequestStatusArgs
func (_e *Client_Expecter) CreatePullRequestStatus(context1 interface{}, createPullRequestStatusArgs interface{}) *Client_CreatePullRequestStatus_Call {
	return &Client_CreatePullRequestStatus_Call{Call: _e.mock.On("CreatePullRequestStatus", context1, createPullRequestStatusArgs)}
}

func (_c *Client_CreatePullRequestStatus_Call) Run(run func(context1 context.Context, createPullRequestStatusArgs git.CreatePullRequestStatusArgs)) *Client_CreatePullRequestStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePullRequestStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePullRequestStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePullRequestStatus_Call) Return(gitPullRequestStatus *git.GitPullRequestStatus, err error) *Client_CreatePullRequestStatus_Call {
	_c.Call.Return(gitPullRequestStatus, err)
	return _c
}

func (_c *Client_CreatePullRequestStatus_Call) RunAndReturn(run func(context1 context.Context, createPullRequestStatusArgs git.CreatePullRequestStatusArgs) (*git.GitPullRequestStatus, error)) *Client_CreatePullRequestStatus_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePush provides a mock function for the type Client
func (_mock *Client) CreatePush(context1 context.Context, createPushArgs git.CreatePushArgs) (*git.GitPush, error) {
	ret := _mock.Called(context1, createPushArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreatePush")
	}

	var r0 *git.GitPush
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePushArgs) (*git.GitPush, error)); ok {
		return returnFunc(context1, createPushArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreatePushArgs) *git.GitPush); ok {
		r0 = returnFunc(context1, createPushArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPush)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreatePushArgs) error); ok {
		r1 = returnFunc(context1, createPushArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreatePush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePush'
type Client_CreatePush_Call struct {
	*mock.Call
}

// CreatePush is a helper method to define mock.On call
//   - context1 context.Context
//   - createPushArgs git.CreatePushArgs
func (_e *Client_Expecter) CreatePush(context1 interface{}, createPushArgs interface{}) *Client_CreatePush_Call {
	return &Client_CreatePush_Call{Call: _e.mock.On("CreatePush", context1, createPushArgs)}
}

func (_c *Client_CreatePush_Call) Run(run func(context1 context.Context, createPushArgs git.CreatePushArgs)) *Client_CreatePush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreatePushArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreatePushArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreatePush_Call) Return(gitPush *git.GitPush, err error) *Client_CreatePush_Call {
	_c.Call.Return(gitPush, err)
	return _c
}

func (_c *Client_CreatePush_Call) RunAndReturn(run func(context1 context.Context, createPushArgs git.CreatePushArgs) (*git.GitPush, error)) *Client_CreatePush_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRepository provides a mock function for the type Client
func (_mock *Client) CreateRepository(context1 context.Context, createRepositoryArgs git.CreateRepositoryArgs) (*git.GitRepository, error) {
	ret := _mock.Called(context1, createRepositoryArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateRepository")
	}

	var r0 *git.GitRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateRepositoryArgs) (*git.GitRepository, error)); ok {
		return returnFunc(context1, createRepositoryArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateRepositoryArgs) *git.GitRepository); ok {
		r0 = returnFunc(context1, createRepositoryArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateRepositoryArgs) error); ok {
		r1 = returnFunc(context1, createRepositoryArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepository'
type Client_CreateRepository_Call struct {
	*mock.Call
}

// CreateRepository is a helper method to define mock.On call
//   - context1 context.Context
//   - createRepositoryArgs git.CreateRepositoryArgs
func (_e *Client_Expecter) CreateRepository(context1 interface{}, createRepositoryArgs interface{}) *Client_CreateRepository_Call {
	return &Client_CreateRepository_Call{Call: _e.mock.On("CreateRepository", context1, createRepositoryArgs)}
}

func (_c *Client_CreateRepository_Call) Run(run func(context1 context.Context, createRepositoryArgs git.CreateRepositoryArgs)) *Client_CreateRepository_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateRepositoryArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateRepositoryArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateRepository_Call) Return(gitRepository *git.GitRepository, err error) *Client_CreateRepository_Call {
	_c.Call.Return(gitRepository, err)
	return _c
}

func (_c *Client_CreateRepository_Call) RunAndReturn(run func(context1 context.Context, createRepositoryArgs git.CreateRepositoryArgs) (*git.GitRepository, error)) *Client_CreateRepository_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRevert provides a mock function for the type Client
func (_mock *Client) CreateRevert(context1 context.Context, createRevertArgs git.CreateRevertArgs) (*git.GitRevert, error) {
	ret := _mock.Called(context1, createRevertArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateRevert")
	}

	var r0 *git.GitRevert
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateRevertArgs) (*git.GitRevert, error)); ok {
		return returnFunc(context1, createRevertArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateRevertArgs) *git.GitRevert); ok {
		r0 = returnFunc(context1, createRevertArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRevert)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateRevertArgs) error); ok {
		r1 = returnFunc(context1, createRevertArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateRevert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRevert'
type Client_CreateRevert_Call struct {
	*mock.Call
}

// CreateRevert is a helper method to define mock.On call
//   - context1 context.Context
//   - createRevertArgs git.CreateRevertArgs
func (_e *Client_Expecter) CreateRevert(context1 interface{}, createRevertArgs interface{}) *Client_CreateRevert_Call {
	return &Client_CreateRevert_Call{Call: _e.mock.On("CreateRevert", context1, createRevertArgs)}
}

func (_c *Client_CreateRevert_Call) Run(run func(context1 context.Context, createRevertArgs git.CreateRevertArgs)) *Client_CreateRevert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateRevertArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateRevertArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateRevert_Call) Return(gitRevert *git.GitRevert, err error) *Client_CreateRevert_Call {
	_c.Call.Return(gitRevert, err)
	return _c
}

func (_c *Client_CreateRevert_Call) RunAndReturn(run func(context1 context.Context, createRevertArgs git.CreateRevertArgs) (*git.GitRevert, error)) *Client_CreateRevert_Call {
	_c.Call.Return(run)
	return _c
}

// CreateThread provides a mock function for the type Client
func (_mock *Client) CreateThread(context1 context.Context, createThreadArgs git.CreateThreadArgs) (*git.GitPullRequestCommentThread, error) {
	ret := _mock.Called(context1, createThreadArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateThread")
	}

	var r0 *git.GitPullRequestCommentThread
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateThreadArgs) (*git.GitPullRequestCommentThread, error)); ok {
		return returnFunc(context1, createThreadArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateThreadArgs) *git.GitPullRequestCommentThread); ok {
		r0 = returnFunc(context1, createThreadArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestCommentThread)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateThreadArgs) error); ok {
		r1 = returnFunc(context1, createThreadArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateThread_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateThread'
type Client_CreateThread_Call struct {
	*mock.Call
}

// CreateThread is a helper method to define mock.On call
//   - context1 context.Context
//   - createThreadArgs git.CreateThreadArgs
func (_e *Client_Expecter) CreateThread(context1 interface{}, createThreadArgs interface{}) *Client_CreateThread_Call {
	return &Client_CreateThread_Call{Call: _e.mock.On("CreateThread", context1, createThreadArgs)}
}

func (_c *Client_CreateThread_Call) Run(run func(context1 context.Context, createThreadArgs git.CreateThreadArgs)) *Client_CreateThread_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateThreadArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateThreadArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateThread_Call) Return(gitPullRequestCommentThread *git.GitPullRequestCommentThread, err error) *Client_CreateThread_Call {
	_c.Call.Return(gitPullRequestCommentThread, err)
	return _c
}

func (_c *Client_CreateThread_Call) RunAndReturn(run func(context1 context.Context, createThreadArgs git.CreateThreadArgs) (*git.GitPullRequestCommentThread, error)) *Client_CreateThread_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUnmaterializedPullRequestReviewer provides a mock function for the type Client
func (_mock *Client) CreateUnmaterializedPullRequestReviewer(context1 context.Context, createUnmaterializedPullRequestReviewerArgs git.CreateUnmaterializedPullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	ret := _mock.Called(context1, createUnmaterializedPullRequestReviewerArgs)

	if len(ret) == 0 {
		panic("no return value specified for CreateUnmaterializedPullRequestReviewer")
	}

	var r0 *git.IdentityRefWithVote
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateUnmaterializedPullRequestReviewerArgs) (*git.IdentityRefWithVote, error)); ok {
		return returnFunc(context1, createUnmaterializedPullRequestReviewerArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.CreateUnmaterializedPullRequestReviewerArgs) *git.IdentityRefWithVote); ok {
		r0 = returnFunc(context1, createUnmaterializedPullRequestReviewerArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.IdentityRefWithVote)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.CreateUnmaterializedPullRequestReviewerArgs) error); ok {
		r1 = returnFunc(context1, createUnmaterializedPullRequestReviewerArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_CreateUnmaterializedPullRequestReviewer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUnmaterializedPullRequestReviewer'
type Client_CreateUnmaterializedPullRequestReviewer_Call struct {
	*mock.Call
}

// CreateUnmaterializedPullRequestReviewer is a helper method to define mock.On call
//   - context1 context.Context
//   - createUnmaterializedPullRequestReviewerArgs git.CreateUnmaterializedPullRequestReviewerArgs
func (_e *Client_Expecter) CreateUnmaterializedPullRequestReviewer(context1 interface{}, createUnmaterializedPullRequestReviewerArgs interface{}) *Client_CreateUnmaterializedPullRequestReviewer_Call {
	return &Client_CreateUnmaterializedPullRequestReviewer_Call{Call: _e.mock.On("CreateUnmaterializedPullRequestReviewer", context1, createUnmaterializedPullRequestReviewerArgs)}
}

func (_c *Client_CreateUnmaterializedPullRequestReviewer_Call) Run(run func(context1 context.Context, createUnmaterializedPullRequestReviewerArgs git.CreateUnmaterializedPullRequestReviewerArgs)) *Client_CreateUnmaterializedPullRequestReviewer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.CreateUnmaterializedPullRequestReviewerArgs
		if args[1] != nil {
			arg1 = args[1].(git.CreateUnmaterializedPullRequestReviewerArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_CreateUnmaterializedPullRequestReviewer_Call) Return(identityRefWithVote *git.IdentityRefWithVote, err error) *Client_CreateUnmaterializedPullRequestReviewer_Call {
	_c.Call.Return(identityRefWithVote, err)
	return _c
}

func (_c *Client_CreateUnmaterializedPullRequestReviewer_Call) RunAndReturn(run func(context1 context.Context, createUnmaterializedPullRequestReviewerArgs git.CreateUnmaterializedPullRequestReviewerArgs) (*git.IdentityRefWithVote, error)) *Client_CreateUnmaterializedPullRequestReviewer_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAttachment provides a mock function for the type Client
func (_mock *Client) DeleteAttachment(context1 context.Context, deleteAttachmentArgs git.DeleteAttachmentArgs) error {
	ret := _mock.Called(context1, deleteAttachmentArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeleteAttachment")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeleteAttachmentArgs) error); ok {
		r0 = returnFunc(context1, deleteAttachmentArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeleteAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAttachment'
type Client_DeleteAttachment_Call struct {
	*mock.Call
}

// DeleteAttachment is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteAttachmentArgs git.DeleteAttachmentArgs
func (_e *Client_Expecter) DeleteAttachment(context1 interface{}, deleteAttachmentArgs interface{}) *Client_DeleteAttachment_Call {
	return &Client_DeleteAttachment_Call{Call: _e.mock.On("DeleteAttachment", context1, deleteAttachmentArgs)}
}

func (_c *Client_DeleteAttachment_Call) Run(run func(context1 context.Context, deleteAttachmentArgs git.DeleteAttachmentArgs)) *Client_DeleteAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeleteAttachmentArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeleteAttachmentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeleteAttachment_Call) Return(err error) *Client_DeleteAttachment_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeleteAttachment_Call) RunAndReturn(run func(context1 context.Context, deleteAttachmentArgs git.DeleteAttachmentArgs) error) *Client_DeleteAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteComment provides a mock function for the type Client
func (_mock *Client) DeleteComment(context1 context.Context, deleteCommentArgs git.DeleteCommentArgs) error {
	ret := _mock.Called(context1, deleteCommentArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeleteComment")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeleteCommentArgs) error); ok {
		r0 = returnFunc(context1, deleteCommentArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeleteComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteComment'
type Client_DeleteComment_Call struct {
	*mock.Call
}

// DeleteComment is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteCommentArgs git.DeleteCommentArgs
func (_e *Client_Expecter) DeleteComment(context1 interface{}, deleteCommentArgs interface{}) *Client_DeleteComment_Call {
	return &Client_DeleteComment_Call{Call: _e.mock.On("DeleteComment", context1, deleteCommentArgs)}
}

func (_c *Client_DeleteComment_Call) Run(run func(context1 context.Context, deleteCommentArgs git.DeleteCommentArgs)) *Client_DeleteComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeleteCommentArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeleteCommentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeleteComment_Call) Return(err error) *Client_DeleteComment_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeleteComment_Call) RunAndReturn(run func(context1 context.Context, deleteCommentArgs git.DeleteCommentArgs) error) *Client_DeleteComment_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLike provides a mock function for the type Client
func (_mock *Client) DeleteLike(context1 context.Context, deleteLikeArgs git.DeleteLikeArgs) error {
	ret := _mock.Called(context1, deleteLikeArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLike")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeleteLikeArgs) error); ok {
		r0 = returnFunc(context1, deleteLikeArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeleteLike_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLike'
type Client_DeleteLike_Call struct {
	*mock.Call
}

// DeleteLike is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteLikeArgs git.DeleteLikeArgs
func (_e *Client_Expecter) DeleteLike(context1 interface{}, deleteLikeArgs interface{}) *Client_DeleteLike_Call {
	return &Client_DeleteLike_Call{Call: _e.mock.On("DeleteLike", context1, deleteLikeArgs)}
}

func (_c *Client_DeleteLike_Call) Run(run func(context1 context.Context, deleteLikeArgs git.DeleteLikeArgs)) *Client_DeleteLike_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeleteLikeArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeleteLikeArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeleteLike_Call) Return(err error) *Client_DeleteLike_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeleteLike_Call) RunAndReturn(run func(context1 context.Context, deleteLikeArgs git.DeleteLikeArgs) error) *Client_DeleteLike_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePullRequestIterationStatus provides a mock function for the type Client
func (_mock *Client) DeletePullRequestIterationStatus(context1 context.Context, deletePullRequestIterationStatusArgs git.DeletePullRequestIterationStatusArgs) error {
	ret := _mock.Called(context1, deletePullRequestIterationStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeletePullRequestIterationStatus")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeletePullRequestIterationStatusArgs) error); ok {
		r0 = returnFunc(context1, deletePullRequestIterationStatusArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeletePullRequestIterationStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePullRequestIterationStatus'
type Client_DeletePullRequestIterationStatus_Call struct {
	*mock.Call
}

// DeletePullRequestIterationStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - deletePullRequestIterationStatusArgs git.DeletePullRequestIterationStatusArgs
func (_e *Client_Expecter) DeletePullRequestIterationStatus(context1 interface{}, deletePullRequestIterationStatusArgs interface{}) *Client_DeletePullRequestIterationStatus_Call {
	return &Client_DeletePullRequestIterationStatus_Call{Call: _e.mock.On("DeletePullRequestIterationStatus", context1, deletePullRequestIterationStatusArgs)}
}

func (_c *Client_DeletePullRequestIterationStatus_Call) Run(run func(context1 context.Context, deletePullRequestIterationStatusArgs git.DeletePullRequestIterationStatusArgs)) *Client_DeletePullRequestIterationStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeletePullRequestIterationStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeletePullRequestIterationStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeletePullRequestIterationStatus_Call) Return(err error) *Client_DeletePullRequestIterationStatus_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeletePullRequestIterationStatus_Call) RunAndReturn(run func(context1 context.Context, deletePullRequestIterationStatusArgs git.DeletePullRequestIterationStatusArgs) error) *Client_DeletePullRequestIterationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePullRequestLabels provides a mock function for the type Client
func (_mock *Client) DeletePullRequestLabels(context1 context.Context, deletePullRequestLabelsArgs git.DeletePullRequestLabelsArgs) error {
	ret := _mock.Called(context1, deletePullRequestLabelsArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeletePullRequestLabels")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeletePullRequestLabelsArgs) error); ok {
		r0 = returnFunc(context1, deletePullRequestLabelsArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeletePullRequestLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePullRequestLabels'
type Client_DeletePullRequestLabels_Call struct {
	*mock.Call
}

// DeletePullRequestLabels is a helper method to define mock.On call
//   - context1 context.Context
//   - deletePullRequestLabelsArgs git.DeletePullRequestLabelsArgs
func (_e *Client_Expecter) DeletePullRequestLabels(context1 interface{}, deletePullRequestLabelsArgs interface{}) *Client_DeletePullRequestLabels_Call {
	return &Client_DeletePullRequestLabels_Call{Call: _e.mock.On("DeletePullRequestLabels", context1, deletePullRequestLabelsArgs)}
}

func (_c *Client_DeletePullRequestLabels_Call) Run(run func(context1 context.Context, deletePullRequestLabelsArgs git.DeletePullRequestLabelsArgs)) *Client_DeletePullRequestLabels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeletePullRequestLabelsArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeletePullRequestLabelsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeletePullRequestLabels_Call) Return(err error) *Client_DeletePullRequestLabels_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeletePullRequestLabels_Call) RunAndReturn(run func(context1 context.Context, deletePullRequestLabelsArgs git.DeletePullRequestLabelsArgs) error) *Client_DeletePullRequestLabels_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePullRequestReviewer provides a mock function for the type Client
func (_mock *Client) DeletePullRequestReviewer(context1 context.Context, deletePullRequestReviewerArgs git.DeletePullRequestReviewerArgs) error {
	ret := _mock.Called(context1, deletePullRequestReviewerArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeletePullRequestReviewer")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeletePullRequestReviewerArgs) error); ok {
		r0 = returnFunc(context1, deletePullRequestReviewerArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeletePullRequestReviewer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePullRequestReviewer'
type Client_DeletePullRequestReviewer_Call struct {
	*mock.Call
}

// DeletePullRequestReviewer is a helper method to define mock.On call
//   - context1 context.Context
//   - deletePullRequestReviewerArgs git.DeletePullRequestReviewerArgs
func (_e *Client_Expecter) DeletePullRequestReviewer(context1 interface{}, deletePullRequestReviewerArgs interface{}) *Client_DeletePullRequestReviewer_Call {
	return &Client_DeletePullRequestReviewer_Call{Call: _e.mock.On("DeletePullRequestReviewer", context1, deletePullRequestReviewerArgs)}
}

func (_c *Client_DeletePullRequestReviewer_Call) Run(run func(context1 context.Context, deletePullRequestReviewerArgs git.DeletePullRequestReviewerArgs)) *Client_DeletePullRequestReviewer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeletePullRequestReviewerArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeletePullRequestReviewerArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeletePullRequestReviewer_Call) Return(err error) *Client_DeletePullRequestReviewer_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeletePullRequestReviewer_Call) RunAndReturn(run func(context1 context.Context, deletePullRequestReviewerArgs git.DeletePullRequestReviewerArgs) error) *Client_DeletePullRequestReviewer_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePullRequestStatus provides a mock function for the type Client
func (_mock *Client) DeletePullRequestStatus(context1 context.Context, deletePullRequestStatusArgs git.DeletePullRequestStatusArgs) error {
	ret := _mock.Called(context1, deletePullRequestStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeletePullRequestStatus")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeletePullRequestStatusArgs) error); ok {
		r0 = returnFunc(context1, deletePullRequestStatusArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeletePullRequestStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePullRequestStatus'
type Client_DeletePullRequestStatus_Call struct {
	*mock.Call
}

// DeletePullRequestStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - deletePullRequestStatusArgs git.DeletePullRequestStatusArgs
func (_e *Client_Expecter) DeletePullRequestStatus(context1 interface{}, deletePullRequestStatusArgs interface{}) *Client_DeletePullRequestStatus_Call {
	return &Client_DeletePullRequestStatus_Call{Call: _e.mock.On("DeletePullRequestStatus", context1, deletePullRequestStatusArgs)}
}

func (_c *Client_DeletePullRequestStatus_Call) Run(run func(context1 context.Context, deletePullRequestStatusArgs git.DeletePullRequestStatusArgs)) *Client_DeletePullRequestStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeletePullRequestStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeletePullRequestStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeletePullRequestStatus_Call) Return(err error) *Client_DeletePullRequestStatus_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeletePullRequestStatus_Call) RunAndReturn(run func(context1 context.Context, deletePullRequestStatusArgs git.DeletePullRequestStatusArgs) error) *Client_DeletePullRequestStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRefFavorite provides a mock function for the type Client
func (_mock *Client) DeleteRefFavorite(context1 context.Context, deleteRefFavoriteArgs git.DeleteRefFavoriteArgs) error {
	ret := _mock.Called(context1, deleteRefFavoriteArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRefFavorite")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeleteRefFavoriteArgs) error); ok {
		r0 = returnFunc(context1, deleteRefFavoriteArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeleteRefFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRefFavorite'
type Client_DeleteRefFavorite_Call struct {
	*mock.Call
}

// DeleteRefFavorite is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteRefFavoriteArgs git.DeleteRefFavoriteArgs
func (_e *Client_Expecter) DeleteRefFavorite(context1 interface{}, deleteRefFavoriteArgs interface{}) *Client_DeleteRefFavorite_Call {
	return &Client_DeleteRefFavorite_Call{Call: _e.mock.On("DeleteRefFavorite", context1, deleteRefFavoriteArgs)}
}

func (_c *Client_DeleteRefFavorite_Call) Run(run func(context1 context.Context, deleteRefFavoriteArgs git.DeleteRefFavoriteArgs)) *Client_DeleteRefFavorite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeleteRefFavoriteArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeleteRefFavoriteArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeleteRefFavorite_Call) Return(err error) *Client_DeleteRefFavorite_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeleteRefFavorite_Call) RunAndReturn(run func(context1 context.Context, deleteRefFavoriteArgs git.DeleteRefFavoriteArgs) error) *Client_DeleteRefFavorite_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRepository provides a mock function for the type Client
func (_mock *Client) DeleteRepository(context1 context.Context, deleteRepositoryArgs git.DeleteRepositoryArgs) error {
	ret := _mock.Called(context1, deleteRepositoryArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRepository")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeleteRepositoryArgs) error); ok {
		r0 = returnFunc(context1, deleteRepositoryArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeleteRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepository'
type Client_DeleteRepository_Call struct {
	*mock.Call
}

// DeleteRepository is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteRepositoryArgs git.DeleteRepositoryArgs
func (_e *Client_Expecter) DeleteRepository(context1 interface{}, deleteRepositoryArgs interface{}) *Client_DeleteRepository_Call {
	return &Client_DeleteRepository_Call{Call: _e.mock.On("DeleteRepository", context1, deleteRepositoryArgs)}
}

func (_c *Client_DeleteRepository_Call) Run(run func(context1 context.Context, deleteRepositoryArgs git.DeleteRepositoryArgs)) *Client_DeleteRepository_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeleteRepositoryArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeleteRepositoryArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeleteRepository_Call) Return(err error) *Client_DeleteRepository_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeleteRepository_Call) RunAndReturn(run func(context1 context.Context, deleteRepositoryArgs git.DeleteRepositoryArgs) error) *Client_DeleteRepository_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRepositoryFromRecycleBin provides a mock function for the type Client
func (_mock *Client) DeleteRepositoryFromRecycleBin(context1 context.Context, deleteRepositoryFromRecycleBinArgs git.DeleteRepositoryFromRecycleBinArgs) error {
	ret := _mock.Called(context1, deleteRepositoryFromRecycleBinArgs)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRepositoryFromRecycleBin")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.DeleteRepositoryFromRecycleBinArgs) error); ok {
		r0 = returnFunc(context1, deleteRepositoryFromRecycleBinArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_DeleteRepositoryFromRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepositoryFromRecycleBin'
type Client_DeleteRepositoryFromRecycleBin_Call struct {
	*mock.Call
}

// DeleteRepositoryFromRecycleBin is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteRepositoryFromRecycleBinArgs git.DeleteRepositoryFromRecycleBinArgs
func (_e *Client_Expecter) DeleteRepositoryFromRecycleBin(context1 interface{}, deleteRepositoryFromRecycleBinArgs interface{}) *Client_DeleteRepositoryFromRecycleBin_Call {
	return &Client_DeleteRepositoryFromRecycleBin_Call{Call: _e.mock.On("DeleteRepositoryFromRecycleBin", context1, deleteRepositoryFromRecycleBinArgs)}
}

func (_c *Client_DeleteRepositoryFromRecycleBin_Call) Run(run func(context1 context.Context, deleteRepositoryFromRecycleBinArgs git.DeleteRepositoryFromRecycleBinArgs)) *Client_DeleteRepositoryFromRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.DeleteRepositoryFromRecycleBinArgs
		if args[1] != nil {
			arg1 = args[1].(git.DeleteRepositoryFromRecycleBinArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_DeleteRepositoryFromRecycleBin_Call) Return(err error) *Client_DeleteRepositoryFromRecycleBin_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_DeleteRepositoryFromRecycleBin_Call) RunAndReturn(run func(context1 context.Context, deleteRepositoryFromRecycleBinArgs git.DeleteRepositoryFromRecycleBinArgs) error) *Client_DeleteRepositoryFromRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// GetAnnotatedTag provides a mock function for the type Client
func (_mock *Client) GetAnnotatedTag(context1 context.Context, getAnnotatedTagArgs git.GetAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
	ret := _mock.Called(context1, getAnnotatedTagArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetAnnotatedTag")
	}

	var r0 *git.GitAnnotatedTag
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAnnotatedTagArgs) (*git.GitAnnotatedTag, error)); ok {
		return returnFunc(context1, getAnnotatedTagArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAnnotatedTagArgs) *git.GitAnnotatedTag); ok {
		r0 = returnFunc(context1, getAnnotatedTagArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitAnnotatedTag)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetAnnotatedTagArgs) error); ok {
		r1 = returnFunc(context1, getAnnotatedTagArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetAnnotatedTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnnotatedTag'
type Client_GetAnnotatedTag_Call struct {
	*mock.Call
}

// GetAnnotatedTag is a helper method to define mock.On call
//   - context1 context.Context
//   - getAnnotatedTagArgs git.GetAnnotatedTagArgs
func (_e *Client_Expecter) GetAnnotatedTag(context1 interface{}, getAnnotatedTagArgs interface{}) *Client_GetAnnotatedTag_Call {
	return &Client_GetAnnotatedTag_Call{Call: _e.mock.On("GetAnnotatedTag", context1, getAnnotatedTagArgs)}
}

func (_c *Client_GetAnnotatedTag_Call) Run(run func(context1 context.Context, getAnnotatedTagArgs git.GetAnnotatedTagArgs)) *Client_GetAnnotatedTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetAnnotatedTagArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetAnnotatedTagArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetAnnotatedTag_Call) Return(gitAnnotatedTag *git.GitAnnotatedTag, err error) *Client_GetAnnotatedTag_Call {
	_c.Call.Return(gitAnnotatedTag, err)
	return _c
}

func (_c *Client_GetAnnotatedTag_Call) RunAndReturn(run func(context1 context.Context, getAnnotatedTagArgs git.GetAnnotatedTagArgs) (*git.GitAnnotatedTag, error)) *Client_GetAnnotatedTag_Call {
	_c.Call.Return(run)
	return _c
}

// GetAttachmentContent provides a mock function for the type Client
func (_mock *Client) GetAttachmentContent(context1 context.Context, getAttachmentContentArgs git.GetAttachmentContentArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getAttachmentContentArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetAttachmentContent")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAttachmentContentArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getAttachmentContentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAttachmentContentArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getAttachmentContentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetAttachmentContentArgs) error); ok {
		r1 = returnFunc(context1, getAttachmentContentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetAttachmentContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAttachmentContent'
type Client_GetAttachmentContent_Call struct {
	*mock.Call
}

// GetAttachmentContent is a helper method to define mock.On call
//   - context1 context.Context
//   - getAttachmentContentArgs git.GetAttachmentContentArgs
func (_e *Client_Expecter) GetAttachmentContent(context1 interface{}, getAttachmentContentArgs interface{}) *Client_GetAttachmentContent_Call {
	return &Client_GetAttachmentContent_Call{Call: _e.mock.On("GetAttachmentContent", context1, getAttachmentContentArgs)}
}

func (_c *Client_GetAttachmentContent_Call) Run(run func(context1 context.Context, getAttachmentContentArgs git.GetAttachmentContentArgs)) *Client_GetAttachmentContent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetAttachmentContentArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetAttachmentContentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetAttachmentContent_Call) Return(readCloser io.ReadCloser, err error) *Client_GetAttachmentContent_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetAttachmentContent_Call) RunAndReturn(run func(context1 context.Context, getAttachmentContentArgs git.GetAttachmentContentArgs) (io.ReadCloser, error)) *Client_GetAttachmentContent_Call {
	_c.Call.Return(run)
	return _c
}

// GetAttachmentZip provides a mock function for the type Client
func (_mock *Client) GetAttachmentZip(context1 context.Context, getAttachmentZipArgs git.GetAttachmentZipArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getAttachmentZipArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetAttachmentZip")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAttachmentZipArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getAttachmentZipArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAttachmentZipArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getAttachmentZipArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetAttachmentZipArgs) error); ok {
		r1 = returnFunc(context1, getAttachmentZipArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetAttachmentZip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAttachmentZip'
type Client_GetAttachmentZip_Call struct {
	*mock.Call
}

// GetAttachmentZip is a helper method to define mock.On call
//   - context1 context.Context
//   - getAttachmentZipArgs git.GetAttachmentZipArgs
func (_e *Client_Expecter) GetAttachmentZip(context1 interface{}, getAttachmentZipArgs interface{}) *Client_GetAttachmentZip_Call {
	return &Client_GetAttachmentZip_Call{Call: _e.mock.On("GetAttachmentZip", context1, getAttachmentZipArgs)}
}

func (_c *Client_GetAttachmentZip_Call) Run(run func(context1 context.Context, getAttachmentZipArgs git.GetAttachmentZipArgs)) *Client_GetAttachmentZip_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetAttachmentZipArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetAttachmentZipArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetAttachmentZip_Call) Return(readCloser io.ReadCloser, err error) *Client_GetAttachmentZip_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetAttachmentZip_Call) RunAndReturn(run func(context1 context.Context, getAttachmentZipArgs git.GetAttachmentZipArgs) (io.ReadCloser, error)) *Client_GetAttachmentZip_Call {
	_c.Call.Return(run)
	return _c
}

// GetAttachments provides a mock function for the type Client
func (_mock *Client) GetAttachments(context1 context.Context, getAttachmentsArgs git.GetAttachmentsArgs) (*[]git.Attachment, error) {
	ret := _mock.Called(context1, getAttachmentsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetAttachments")
	}

	var r0 *[]git.Attachment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAttachmentsArgs) (*[]git.Attachment, error)); ok {
		return returnFunc(context1, getAttachmentsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetAttachmentsArgs) *[]git.Attachment); ok {
		r0 = returnFunc(context1, getAttachmentsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.Attachment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetAttachmentsArgs) error); ok {
		r1 = returnFunc(context1, getAttachmentsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAttachments'
type Client_GetAttachments_Call struct {
	*mock.Call
}

// GetAttachments is a helper method to define mock.On call
//   - context1 context.Context
//   - getAttachmentsArgs git.GetAttachmentsArgs
func (_e *Client_Expecter) GetAttachments(context1 interface{}, getAttachmentsArgs interface{}) *Client_GetAttachments_Call {
	return &Client_GetAttachments_Call{Call: _e.mock.On("GetAttachments", context1, getAttachmentsArgs)}
}

func (_c *Client_GetAttachments_Call) Run(run func(context1 context.Context, getAttachmentsArgs git.GetAttachmentsArgs)) *Client_GetAttachments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetAttachmentsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetAttachmentsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetAttachments_Call) Return(attachments *[]git.Attachment, err error) *Client_GetAttachments_Call {
	_c.Call.Return(attachments, err)
	return _c
}

func (_c *Client_GetAttachments_Call) RunAndReturn(run func(context1 context.Context, getAttachmentsArgs git.GetAttachmentsArgs) (*[]git.Attachment, error)) *Client_GetAttachments_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlob provides a mock function for the type Client
func (_mock *Client) GetBlob(context1 context.Context, getBlobArgs git.GetBlobArgs) (*git.GitBlobRef, error) {
	ret := _mock.Called(context1, getBlobArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetBlob")
	}

	var r0 *git.GitBlobRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobArgs) (*git.GitBlobRef, error)); ok {
		return returnFunc(context1, getBlobArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobArgs) *git.GitBlobRef); ok {
		r0 = returnFunc(context1, getBlobArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitBlobRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetBlobArgs) error); ok {
		r1 = returnFunc(context1, getBlobArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlob'
type Client_GetBlob_Call struct {
	*mock.Call
}

// GetBlob is a helper method to define mock.On call
//   - context1 context.Context
//   - getBlobArgs git.GetBlobArgs
func (_e *Client_Expecter) GetBlob(context1 interface{}, getBlobArgs interface{}) *Client_GetBlob_Call {
	return &Client_GetBlob_Call{Call: _e.mock.On("GetBlob", context1, getBlobArgs)}
}

func (_c *Client_GetBlob_Call) Run(run func(context1 context.Context, getBlobArgs git.GetBlobArgs)) *Client_GetBlob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetBlobArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetBlobArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetBlob_Call) Return(gitBlobRef *git.GitBlobRef, err error) *Client_GetBlob_Call {
	_c.Call.Return(gitBlobRef, err)
	return _c
}

func (_c *Client_GetBlob_Call) RunAndReturn(run func(context1 context.Context, getBlobArgs git.GetBlobArgs) (*git.GitBlobRef, error)) *Client_GetBlob_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlobContent provides a mock function for the type Client
func (_mock *Client) GetBlobContent(context1 context.Context, getBlobContentArgs git.GetBlobContentArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getBlobContentArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetBlobContent")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobContentArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getBlobContentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobContentArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getBlobContentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetBlobContentArgs) error); ok {
		r1 = returnFunc(context1, getBlobContentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetBlobContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlobContent'
type Client_GetBlobContent_Call struct {
	*mock.Call
}

// GetBlobContent is a helper method to define mock.On call
//   - context1 context.Context
//   - getBlobContentArgs git.GetBlobContentArgs
func (_e *Client_Expecter) GetBlobContent(context1 interface{}, getBlobContentArgs interface{}) *Client_GetBlobContent_Call {
	return &Client_GetBlobContent_Call{Call: _e.mock.On("GetBlobContent", context1, getBlobContentArgs)}
}

func (_c *Client_GetBlobContent_Call) Run(run func(context1 context.Context, getBlobContentArgs git.GetBlobContentArgs)) *Client_GetBlobContent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetBlobContentArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetBlobContentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetBlobContent_Call) Return(readCloser io.ReadCloser, err error) *Client_GetBlobContent_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetBlobContent_Call) RunAndReturn(run func(context1 context.Context, getBlobContentArgs git.GetBlobContentArgs) (io.ReadCloser, error)) *Client_GetBlobContent_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlobZip provides a mock function for the type Client
func (_mock *Client) GetBlobZip(context1 context.Context, getBlobZipArgs git.GetBlobZipArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getBlobZipArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetBlobZip")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobZipArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getBlobZipArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobZipArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getBlobZipArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetBlobZipArgs) error); ok {
		r1 = returnFunc(context1, getBlobZipArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetBlobZip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlobZip'
type Client_GetBlobZip_Call struct {
	*mock.Call
}

// GetBlobZip is a helper method to define mock.On call
//   - context1 context.Context
//   - getBlobZipArgs git.GetBlobZipArgs
func (_e *Client_Expecter) GetBlobZip(context1 interface{}, getBlobZipArgs interface{}) *Client_GetBlobZip_Call {
	return &Client_GetBlobZip_Call{Call: _e.mock.On("GetBlobZip", context1, getBlobZipArgs)}
}

func (_c *Client_GetBlobZip_Call) Run(run func(context1 context.Context, getBlobZipArgs git.GetBlobZipArgs)) *Client_GetBlobZip_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetBlobZipArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetBlobZipArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetBlobZip_Call) Return(readCloser io.ReadCloser, err error) *Client_GetBlobZip_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetBlobZip_Call) RunAndReturn(run func(context1 context.Context, getBlobZipArgs git.GetBlobZipArgs) (io.ReadCloser, error)) *Client_GetBlobZip_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlobsZip provides a mock function for the type Client
func (_mock *Client) GetBlobsZip(context1 context.Context, getBlobsZipArgs git.GetBlobsZipArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getBlobsZipArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetBlobsZip")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobsZipArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getBlobsZipArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBlobsZipArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getBlobsZipArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetBlobsZipArgs) error); ok {
		r1 = returnFunc(context1, getBlobsZipArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetBlobsZip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlobsZip'
type Client_GetBlobsZip_Call struct {
	*mock.Call
}

// GetBlobsZip is a helper method to define mock.On call
//   - context1 context.Context
//   - getBlobsZipArgs git.GetBlobsZipArgs
func (_e *Client_Expecter) GetBlobsZip(context1 interface{}, getBlobsZipArgs interface{}) *Client_GetBlobsZip_Call {
	return &Client_GetBlobsZip_Call{Call: _e.mock.On("GetBlobsZip", context1, getBlobsZipArgs)}
}

func (_c *Client_GetBlobsZip_Call) Run(run func(context1 context.Context, getBlobsZipArgs git.GetBlobsZipArgs)) *Client_GetBlobsZip_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetBlobsZipArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetBlobsZipArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetBlobsZip_Call) Return(readCloser io.ReadCloser, err error) *Client_GetBlobsZip_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetBlobsZip_Call) RunAndReturn(run func(context1 context.Context, getBlobsZipArgs git.GetBlobsZipArgs) (io.ReadCloser, error)) *Client_GetBlobsZip_Call {
	_c.Call.Return(run)
	return _c
}

// GetBranch provides a mock function for the type Client
func (_mock *Client) GetBranch(context1 context.Context, getBranchArgs git.GetBranchArgs) (*git.GitBranchStats, error) {
	ret := _mock.Called(context1, getBranchArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetBranch")
	}

	var r0 *git.GitBranchStats
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBranchArgs) (*git.GitBranchStats, error)); ok {
		return returnFunc(context1, getBranchArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBranchArgs) *git.GitBranchStats); ok {
		r0 = returnFunc(context1, getBranchArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitBranchStats)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetBranchArgs) error); ok {
		r1 = returnFunc(context1, getBranchArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBranch'
type Client_GetBranch_Call struct {
	*mock.Call
}

// GetBranch is a helper method to define mock.On call
//   - context1 context.Context
//   - getBranchArgs git.GetBranchArgs
func (_e *Client_Expecter) GetBranch(context1 interface{}, getBranchArgs interface{}) *Client_GetBranch_Call {
	return &Client_GetBranch_Call{Call: _e.mock.On("GetBranch", context1, getBranchArgs)}
}

func (_c *Client_GetBranch_Call) Run(run func(context1 context.Context, getBranchArgs git.GetBranchArgs)) *Client_GetBranch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetBranchArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetBranchArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetBranch_Call) Return(gitBranchStats *git.GitBranchStats, err error) *Client_GetBranch_Call {
	_c.Call.Return(gitBranchStats, err)
	return _c
}

func (_c *Client_GetBranch_Call) RunAndReturn(run func(context1 context.Context, getBranchArgs git.GetBranchArgs) (*git.GitBranchStats, error)) *Client_GetBranch_Call {
	_c.Call.Return(run)
	return _c
}

// GetBranches provides a mock function for the type Client
func (_mock *Client) GetBranches(context1 context.Context, getBranchesArgs git.GetBranchesArgs) (*[]git.GitBranchStats, error) {
	ret := _mock.Called(context1, getBranchesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetBranches")
	}

	var r0 *[]git.GitBranchStats
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBranchesArgs) (*[]git.GitBranchStats, error)); ok {
		return returnFunc(context1, getBranchesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetBranchesArgs) *[]git.GitBranchStats); ok {
		r0 = returnFunc(context1, getBranchesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitBranchStats)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetBranchesArgs) error); ok {
		r1 = returnFunc(context1, getBranchesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetBranches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBranches'
type Client_GetBranches_Call struct {
	*mock.Call
}

// GetBranches is a helper method to define mock.On call
//   - context1 context.Context
//   - getBranchesArgs git.GetBranchesArgs
func (_e *Client_Expecter) GetBranches(context1 interface{}, getBranchesArgs interface{}) *Client_GetBranches_Call {
	return &Client_GetBranches_Call{Call: _e.mock.On("GetBranches", context1, getBranchesArgs)}
}

func (_c *Client_GetBranches_Call) Run(run func(context1 context.Context, getBranchesArgs git.GetBranchesArgs)) *Client_GetBranches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetBranchesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetBranchesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetBranches_Call) Return(gitBranchStatss *[]git.GitBranchStats, err error) *Client_GetBranches_Call {
	_c.Call.Return(gitBranchStatss, err)
	return _c
}

func (_c *Client_GetBranches_Call) RunAndReturn(run func(context1 context.Context, getBranchesArgs git.GetBranchesArgs) (*[]git.GitBranchStats, error)) *Client_GetBranches_Call {
	_c.Call.Return(run)
	return _c
}

// GetChanges provides a mock function for the type Client
func (_mock *Client) GetChanges(context1 context.Context, getChangesArgs git.GetChangesArgs) (*git.GitCommitChanges, error) {
	ret := _mock.Called(context1, getChangesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetChanges")
	}

	var r0 *git.GitCommitChanges
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetChangesArgs) (*git.GitCommitChanges, error)); ok {
		return returnFunc(context1, getChangesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetChangesArgs) *git.GitCommitChanges); ok {
		r0 = returnFunc(context1, getChangesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCommitChanges)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetChangesArgs) error); ok {
		r1 = returnFunc(context1, getChangesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetChanges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChanges'
type Client_GetChanges_Call struct {
	*mock.Call
}

// GetChanges is a helper method to define mock.On call
//   - context1 context.Context
//   - getChangesArgs git.GetChangesArgs
func (_e *Client_Expecter) GetChanges(context1 interface{}, getChangesArgs interface{}) *Client_GetChanges_Call {
	return &Client_GetChanges_Call{Call: _e.mock.On("GetChanges", context1, getChangesArgs)}
}

func (_c *Client_GetChanges_Call) Run(run func(context1 context.Context, getChangesArgs git.GetChangesArgs)) *Client_GetChanges_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetChangesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetChangesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetChanges_Call) Return(gitCommitChanges *git.GitCommitChanges, err error) *Client_GetChanges_Call {
	_c.Call.Return(gitCommitChanges, err)
	return _c
}

func (_c *Client_GetChanges_Call) RunAndReturn(run func(context1 context.Context, getChangesArgs git.GetChangesArgs) (*git.GitCommitChanges, error)) *Client_GetChanges_Call {
	_c.Call.Return(run)
	return _c
}

// GetCherryPick provides a mock function for the type Client
func (_mock *Client) GetCherryPick(context1 context.Context, getCherryPickArgs git.GetCherryPickArgs) (*git.GitCherryPick, error) {
	ret := _mock.Called(context1, getCherryPickArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetCherryPick")
	}

	var r0 *git.GitCherryPick
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCherryPickArgs) (*git.GitCherryPick, error)); ok {
		return returnFunc(context1, getCherryPickArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCherryPickArgs) *git.GitCherryPick); ok {
		r0 = returnFunc(context1, getCherryPickArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCherryPick)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCherryPickArgs) error); ok {
		r1 = returnFunc(context1, getCherryPickArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetCherryPick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCherryPick'
type Client_GetCherryPick_Call struct {
	*mock.Call
}

// GetCherryPick is a helper method to define mock.On call
//   - context1 context.Context
//   - getCherryPickArgs git.GetCherryPickArgs
func (_e *Client_Expecter) GetCherryPick(context1 interface{}, getCherryPickArgs interface{}) *Client_GetCherryPick_Call {
	return &Client_GetCherryPick_Call{Call: _e.mock.On("GetCherryPick", context1, getCherryPickArgs)}
}

func (_c *Client_GetCherryPick_Call) Run(run func(context1 context.Context, getCherryPickArgs git.GetCherryPickArgs)) *Client_GetCherryPick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCherryPickArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCherryPickArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetCherryPick_Call) Return(gitCherryPick *git.GitCherryPick, err error) *Client_GetCherryPick_Call {
	_c.Call.Return(gitCherryPick, err)
	return _c
}

func (_c *Client_GetCherryPick_Call) RunAndReturn(run func(context1 context.Context, getCherryPickArgs git.GetCherryPickArgs) (*git.GitCherryPick, error)) *Client_GetCherryPick_Call {
	_c.Call.Return(run)
	return _c
}

// GetCherryPickForRefName provides a mock function for the type Client
func (_mock *Client) GetCherryPickForRefName(context1 context.Context, getCherryPickForRefNameArgs git.GetCherryPickForRefNameArgs) (*git.GitCherryPick, error) {
	ret := _mock.Called(context1, getCherryPickForRefNameArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetCherryPickForRefName")
	}

	var r0 *git.GitCherryPick
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCherryPickForRefNameArgs) (*git.GitCherryPick, error)); ok {
		return returnFunc(context1, getCherryPickForRefNameArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCherryPickForRefNameArgs) *git.GitCherryPick); ok {
		r0 = returnFunc(context1, getCherryPickForRefNameArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCherryPick)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCherryPickForRefNameArgs) error); ok {
		r1 = returnFunc(context1, getCherryPickForRefNameArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetCherryPickForRefName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCherryPickForRefName'
type Client_GetCherryPickForRefName_Call struct {
	*mock.Call
}

// GetCherryPickForRefName is a helper method to define mock.On call
//   - context1 context.Context
//   - getCherryPickForRefNameArgs git.GetCherryPickForRefNameArgs
func (_e *Client_Expecter) GetCherryPickForRefName(context1 interface{}, getCherryPickForRefNameArgs interface{}) *Client_GetCherryPickForRefName_Call {
	return &Client_GetCherryPickForRefName_Call{Call: _e.mock.On("GetCherryPickForRefName", context1, getCherryPickForRefNameArgs)}
}

func (_c *Client_GetCherryPickForRefName_Call) Run(run func(context1 context.Context, getCherryPickForRefNameArgs git.GetCherryPickForRefNameArgs)) *Client_GetCherryPickForRefName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCherryPickForRefNameArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCherryPickForRefNameArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetCherryPickForRefName_Call) Return(gitCherryPick *git.GitCherryPick, err error) *Client_GetCherryPickForRefName_Call {
	_c.Call.Return(gitCherryPick, err)
	return _c
}

func (_c *Client_GetCherryPickForRefName_Call) RunAndReturn(run func(context1 context.Context, getCherryPickForRefNameArgs git.GetCherryPickForRefNameArgs) (*git.GitCherryPick, error)) *Client_GetCherryPickForRefName_Call {
	_c.Call.Return(run)
	return _c
}

// GetComment provides a mock function for the type Client
func (_mock *Client) GetComment(context1 context.Context, getCommentArgs git.GetCommentArgs) (*git.Comment, error) {
	ret := _mock.Called(context1, getCommentArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetComment")
	}

	var r0 *git.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommentArgs) (*git.Comment, error)); ok {
		return returnFunc(context1, getCommentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommentArgs) *git.Comment); ok {
		r0 = returnFunc(context1, getCommentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Comment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCommentArgs) error); ok {
		r1 = returnFunc(context1, getCommentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComment'
type Client_GetComment_Call struct {
	*mock.Call
}

// GetComment is a helper method to define mock.On call
//   - context1 context.Context
//   - getCommentArgs git.GetCommentArgs
func (_e *Client_Expecter) GetComment(context1 interface{}, getCommentArgs interface{}) *Client_GetComment_Call {
	return &Client_GetComment_Call{Call: _e.mock.On("GetComment", context1, getCommentArgs)}
}

func (_c *Client_GetComment_Call) Run(run func(context1 context.Context, getCommentArgs git.GetCommentArgs)) *Client_GetComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCommentArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCommentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetComment_Call) Return(comment *git.Comment, err error) *Client_GetComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *Client_GetComment_Call) RunAndReturn(run func(context1 context.Context, getCommentArgs git.GetCommentArgs) (*git.Comment, error)) *Client_GetComment_Call {
	_c.Call.Return(run)
	return _c
}

// GetComments provides a mock function for the type Client
func (_mock *Client) GetComments(context1 context.Context, getCommentsArgs git.GetCommentsArgs) (*[]git.Comment, error) {
	ret := _mock.Called(context1, getCommentsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetComments")
	}

	var r0 *[]git.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommentsArgs) (*[]git.Comment, error)); ok {
		return returnFunc(context1, getCommentsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommentsArgs) *[]git.Comment); ok {
		r0 = returnFunc(context1, getCommentsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.Comment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCommentsArgs) error); ok {
		r1 = returnFunc(context1, getCommentsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetComments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComments'
type Client_GetComments_Call struct {
	*mock.Call
}

// GetComments is a helper method to define mock.On call
//   - context1 context.Context
//   - getCommentsArgs git.GetCommentsArgs
func (_e *Client_Expecter) GetComments(context1 interface{}, getCommentsArgs interface{}) *Client_GetComments_Call {
	return &Client_GetComments_Call{Call: _e.mock.On("GetComments", context1, getCommentsArgs)}
}

func (_c *Client_GetComments_Call) Run(run func(context1 context.Context, getCommentsArgs git.GetCommentsArgs)) *Client_GetComments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCommentsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCommentsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetComments_Call) Return(comments *[]git.Comment, err error) *Client_GetComments_Call {
	_c.Call.Return(comments, err)
	return _c
}

func (_c *Client_GetComments_Call) RunAndReturn(run func(context1 context.Context, getCommentsArgs git.GetCommentsArgs) (*[]git.Comment, error)) *Client_GetComments_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommit provides a mock function for the type Client
func (_mock *Client) GetCommit(context1 context.Context, getCommitArgs git.GetCommitArgs) (*git.GitCommit, error) {
	ret := _mock.Called(context1, getCommitArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetCommit")
	}

	var r0 *git.GitCommit
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitArgs) (*git.GitCommit, error)); ok {
		return returnFunc(context1, getCommitArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitArgs) *git.GitCommit); ok {
		r0 = returnFunc(context1, getCommitArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCommit)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCommitArgs) error); ok {
		r1 = returnFunc(context1, getCommitArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetCommit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommit'
type Client_GetCommit_Call struct {
	*mock.Call
}

// GetCommit is a helper method to define mock.On call
//   - context1 context.Context
//   - getCommitArgs git.GetCommitArgs
func (_e *Client_Expecter) GetCommit(context1 interface{}, getCommitArgs interface{}) *Client_GetCommit_Call {
	return &Client_GetCommit_Call{Call: _e.mock.On("GetCommit", context1, getCommitArgs)}
}

func (_c *Client_GetCommit_Call) Run(run func(context1 context.Context, getCommitArgs git.GetCommitArgs)) *Client_GetCommit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCommitArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCommitArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetCommit_Call) Return(gitCommit *git.GitCommit, err error) *Client_GetCommit_Call {
	_c.Call.Return(gitCommit, err)
	return _c
}

func (_c *Client_GetCommit_Call) RunAndReturn(run func(context1 context.Context, getCommitArgs git.GetCommitArgs) (*git.GitCommit, error)) *Client_GetCommit_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommitDiffs provides a mock function for the type Client
func (_mock *Client) GetCommitDiffs(context1 context.Context, getCommitDiffsArgs git.GetCommitDiffsArgs) (*git.GitCommitDiffs, error) {
	ret := _mock.Called(context1, getCommitDiffsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetCommitDiffs")
	}

	var r0 *git.GitCommitDiffs
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitDiffsArgs) (*git.GitCommitDiffs, error)); ok {
		return returnFunc(context1, getCommitDiffsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitDiffsArgs) *git.GitCommitDiffs); ok {
		r0 = returnFunc(context1, getCommitDiffsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitCommitDiffs)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCommitDiffsArgs) error); ok {
		r1 = returnFunc(context1, getCommitDiffsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetCommitDiffs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommitDiffs'
type Client_GetCommitDiffs_Call struct {
	*mock.Call
}

// GetCommitDiffs is a helper method to define mock.On call
//   - context1 context.Context
//   - getCommitDiffsArgs git.GetCommitDiffsArgs
func (_e *Client_Expecter) GetCommitDiffs(context1 interface{}, getCommitDiffsArgs interface{}) *Client_GetCommitDiffs_Call {
	return &Client_GetCommitDiffs_Call{Call: _e.mock.On("GetCommitDiffs", context1, getCommitDiffsArgs)}
}

func (_c *Client_GetCommitDiffs_Call) Run(run func(context1 context.Context, getCommitDiffsArgs git.GetCommitDiffsArgs)) *Client_GetCommitDiffs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCommitDiffsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCommitDiffsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetCommitDiffs_Call) Return(gitCommitDiffs *git.GitCommitDiffs, err error) *Client_GetCommitDiffs_Call {
	_c.Call.Return(gitCommitDiffs, err)
	return _c
}

func (_c *Client_GetCommitDiffs_Call) RunAndReturn(run func(context1 context.Context, getCommitDiffsArgs git.GetCommitDiffsArgs) (*git.GitCommitDiffs, error)) *Client_GetCommitDiffs_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommits provides a mock function for the type Client
func (_mock *Client) GetCommits(context1 context.Context, getCommitsArgs git.GetCommitsArgs) (*[]git.GitCommitRef, error) {
	ret := _mock.Called(context1, getCommitsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetCommits")
	}

	var r0 *[]git.GitCommitRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitsArgs) (*[]git.GitCommitRef, error)); ok {
		return returnFunc(context1, getCommitsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitsArgs) *[]git.GitCommitRef); ok {
		r0 = returnFunc(context1, getCommitsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCommitsArgs) error); ok {
		r1 = returnFunc(context1, getCommitsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommits'
type Client_GetCommits_Call struct {
	*mock.Call
}

// GetCommits is a helper method to define mock.On call
//   - context1 context.Context
//   - getCommitsArgs git.GetCommitsArgs
func (_e *Client_Expecter) GetCommits(context1 interface{}, getCommitsArgs interface{}) *Client_GetCommits_Call {
	return &Client_GetCommits_Call{Call: _e.mock.On("GetCommits", context1, getCommitsArgs)}
}

func (_c *Client_GetCommits_Call) Run(run func(context1 context.Context, getCommitsArgs git.GetCommitsArgs)) *Client_GetCommits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCommitsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCommitsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetCommits_Call) Return(gitCommitRefs *[]git.GitCommitRef, err error) *Client_GetCommits_Call {
	_c.Call.Return(gitCommitRefs, err)
	return _c
}

func (_c *Client_GetCommits_Call) RunAndReturn(run func(context1 context.Context, getCommitsArgs git.GetCommitsArgs) (*[]git.GitCommitRef, error)) *Client_GetCommits_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommitsBatch provides a mock function for the type Client
func (_mock *Client) GetCommitsBatch(context1 context.Context, getCommitsBatchArgs git.GetCommitsBatchArgs) (*[]git.GitCommitRef, error) {
	ret := _mock.Called(context1, getCommitsBatchArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetCommitsBatch")
	}

	var r0 *[]git.GitCommitRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitsBatchArgs) (*[]git.GitCommitRef, error)); ok {
		return returnFunc(context1, getCommitsBatchArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetCommitsBatchArgs) *[]git.GitCommitRef); ok {
		r0 = returnFunc(context1, getCommitsBatchArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetCommitsBatchArgs) error); ok {
		r1 = returnFunc(context1, getCommitsBatchArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetCommitsBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommitsBatch'
type Client_GetCommitsBatch_Call struct {
	*mock.Call
}

// GetCommitsBatch is a helper method to define mock.On call
//   - context1 context.Context
//   - getCommitsBatchArgs git.GetCommitsBatchArgs
func (_e *Client_Expecter) GetCommitsBatch(context1 interface{}, getCommitsBatchArgs interface{}) *Client_GetCommitsBatch_Call {
	return &Client_GetCommitsBatch_Call{Call: _e.mock.On("GetCommitsBatch", context1, getCommitsBatchArgs)}
}

func (_c *Client_GetCommitsBatch_Call) Run(run func(context1 context.Context, getCommitsBatchArgs git.GetCommitsBatchArgs)) *Client_GetCommitsBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetCommitsBatchArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetCommitsBatchArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetCommitsBatch_Call) Return(gitCommitRefs *[]git.GitCommitRef, err error) *Client_GetCommitsBatch_Call {
	_c.Call.Return(gitCommitRefs, err)
	return _c
}

func (_c *Client_GetCommitsBatch_Call) RunAndReturn(run func(context1 context.Context, getCommitsBatchArgs git.GetCommitsBatchArgs) (*[]git.GitCommitRef, error)) *Client_GetCommitsBatch_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeletedRepositories provides a mock function for the type Client
func (_mock *Client) GetDeletedRepositories(context1 context.Context, getDeletedRepositoriesArgs git.GetDeletedRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
	ret := _mock.Called(context1, getDeletedRepositoriesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetDeletedRepositories")
	}

	var r0 *[]git.GitDeletedRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetDeletedRepositoriesArgs) (*[]git.GitDeletedRepository, error)); ok {
		return returnFunc(context1, getDeletedRepositoriesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetDeletedRepositoriesArgs) *[]git.GitDeletedRepository); ok {
		r0 = returnFunc(context1, getDeletedRepositoriesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitDeletedRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetDeletedRepositoriesArgs) error); ok {
		r1 = returnFunc(context1, getDeletedRepositoriesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetDeletedRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeletedRepositories'
type Client_GetDeletedRepositories_Call struct {
	*mock.Call
}

// GetDeletedRepositories is a helper method to define mock.On call
//   - context1 context.Context
//   - getDeletedRepositoriesArgs git.GetDeletedRepositoriesArgs
func (_e *Client_Expecter) GetDeletedRepositories(context1 interface{}, getDeletedRepositoriesArgs interface{}) *Client_GetDeletedRepositories_Call {
	return &Client_GetDeletedRepositories_Call{Call: _e.mock.On("GetDeletedRepositories", context1, getDeletedRepositoriesArgs)}
}

func (_c *Client_GetDeletedRepositories_Call) Run(run func(context1 context.Context, getDeletedRepositoriesArgs git.GetDeletedRepositoriesArgs)) *Client_GetDeletedRepositories_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetDeletedRepositoriesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetDeletedRepositoriesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetDeletedRepositories_Call) Return(gitDeletedRepositorys *[]git.GitDeletedRepository, err error) *Client_GetDeletedRepositories_Call {
	_c.Call.Return(gitDeletedRepositorys, err)
	return _c
}

func (_c *Client_GetDeletedRepositories_Call) RunAndReturn(run func(context1 context.Context, getDeletedRepositoriesArgs git.GetDeletedRepositoriesArgs) (*[]git.GitDeletedRepository, error)) *Client_GetDeletedRepositories_Call {
	_c.Call.Return(run)
	return _c
}

// GetForkSyncRequest provides a mock function for the type Client
func (_mock *Client) GetForkSyncRequest(context1 context.Context, getForkSyncRequestArgs git.GetForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
	ret := _mock.Called(context1, getForkSyncRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetForkSyncRequest")
	}

	var r0 *git.GitForkSyncRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetForkSyncRequestArgs) (*git.GitForkSyncRequest, error)); ok {
		return returnFunc(context1, getForkSyncRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetForkSyncRequestArgs) *git.GitForkSyncRequest); ok {
		r0 = returnFunc(context1, getForkSyncRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitForkSyncRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetForkSyncRequestArgs) error); ok {
		r1 = returnFunc(context1, getForkSyncRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetForkSyncRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetForkSyncRequest'
type Client_GetForkSyncRequest_Call struct {
	*mock.Call
}

// GetForkSyncRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - getForkSyncRequestArgs git.GetForkSyncRequestArgs
func (_e *Client_Expecter) GetForkSyncRequest(context1 interface{}, getForkSyncRequestArgs interface{}) *Client_GetForkSyncRequest_Call {
	return &Client_GetForkSyncRequest_Call{Call: _e.mock.On("GetForkSyncRequest", context1, getForkSyncRequestArgs)}
}

func (_c *Client_GetForkSyncRequest_Call) Run(run func(context1 context.Context, getForkSyncRequestArgs git.GetForkSyncRequestArgs)) *Client_GetForkSyncRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetForkSyncRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetForkSyncRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetForkSyncRequest_Call) Return(gitForkSyncRequest *git.GitForkSyncRequest, err error) *Client_GetForkSyncRequest_Call {
	_c.Call.Return(gitForkSyncRequest, err)
	return _c
}

func (_c *Client_GetForkSyncRequest_Call) RunAndReturn(run func(context1 context.Context, getForkSyncRequestArgs git.GetForkSyncRequestArgs) (*git.GitForkSyncRequest, error)) *Client_GetForkSyncRequest_Call {
	_c.Call.Return(run)
	return _c
}

// GetForkSyncRequests provides a mock function for the type Client
func (_mock *Client) GetForkSyncRequests(context1 context.Context, getForkSyncRequestsArgs git.GetForkSyncRequestsArgs) (*[]git.GitForkSyncRequest, error) {
	ret := _mock.Called(context1, getForkSyncRequestsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetForkSyncRequests")
	}

	var r0 *[]git.GitForkSyncRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetForkSyncRequestsArgs) (*[]git.GitForkSyncRequest, error)); ok {
		return returnFunc(context1, getForkSyncRequestsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetForkSyncRequestsArgs) *[]git.GitForkSyncRequest); ok {
		r0 = returnFunc(context1, getForkSyncRequestsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitForkSyncRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetForkSyncRequestsArgs) error); ok {
		r1 = returnFunc(context1, getForkSyncRequestsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetForkSyncRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetForkSyncRequests'
type Client_GetForkSyncRequests_Call struct {
	*mock.Call
}

// GetForkSyncRequests is a helper method to define mock.On call
//   - context1 context.Context
//   - getForkSyncRequestsArgs git.GetForkSyncRequestsArgs
func (_e *Client_Expecter) GetForkSyncRequests(context1 interface{}, getForkSyncRequestsArgs interface{}) *Client_GetForkSyncRequests_Call {
	return &Client_GetForkSyncRequests_Call{Call: _e.mock.On("GetForkSyncRequests", context1, getForkSyncRequestsArgs)}
}

func (_c *Client_GetForkSyncRequests_Call) Run(run func(context1 context.Context, getForkSyncRequestsArgs git.GetForkSyncRequestsArgs)) *Client_GetForkSyncRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetForkSyncRequestsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetForkSyncRequestsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetForkSyncRequests_Call) Return(gitForkSyncRequests *[]git.GitForkSyncRequest, err error) *Client_GetForkSyncRequests_Call {
	_c.Call.Return(gitForkSyncRequests, err)
	return _c
}

func (_c *Client_GetForkSyncRequests_Call) RunAndReturn(run func(context1 context.Context, getForkSyncRequestsArgs git.GetForkSyncRequestsArgs) (*[]git.GitForkSyncRequest, error)) *Client_GetForkSyncRequests_Call {
	_c.Call.Return(run)
	return _c
}

// GetForks provides a mock function for the type Client
func (_mock *Client) GetForks(context1 context.Context, getForksArgs git.GetForksArgs) (*[]git.GitRepositoryRef, error) {
	ret := _mock.Called(context1, getForksArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetForks")
	}

	var r0 *[]git.GitRepositoryRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetForksArgs) (*[]git.GitRepositoryRef, error)); ok {
		return returnFunc(context1, getForksArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetForksArgs) *[]git.GitRepositoryRef); ok {
		r0 = returnFunc(context1, getForksArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRepositoryRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetForksArgs) error); ok {
		r1 = returnFunc(context1, getForksArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetForks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetForks'
type Client_GetForks_Call struct {
	*mock.Call
}

// GetForks is a helper method to define mock.On call
//   - context1 context.Context
//   - getForksArgs git.GetForksArgs
func (_e *Client_Expecter) GetForks(context1 interface{}, getForksArgs interface{}) *Client_GetForks_Call {
	return &Client_GetForks_Call{Call: _e.mock.On("GetForks", context1, getForksArgs)}
}

func (_c *Client_GetForks_Call) Run(run func(context1 context.Context, getForksArgs git.GetForksArgs)) *Client_GetForks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetForksArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetForksArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetForks_Call) Return(gitRepositoryRefs *[]git.GitRepositoryRef, err error) *Client_GetForks_Call {
	_c.Call.Return(gitRepositoryRefs, err)
	return _c
}

func (_c *Client_GetForks_Call) RunAndReturn(run func(context1 context.Context, getForksArgs git.GetForksArgs) (*[]git.GitRepositoryRef, error)) *Client_GetForks_Call {
	_c.Call.Return(run)
	return _c
}

// GetImportRequest provides a mock function for the type Client
func (_mock *Client) GetImportRequest(context1 context.Context, getImportRequestArgs git.GetImportRequestArgs) (*git.GitImportRequest, error) {
	ret := _mock.Called(context1, getImportRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetImportRequest")
	}

	var r0 *git.GitImportRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetImportRequestArgs) (*git.GitImportRequest, error)); ok {
		return returnFunc(context1, getImportRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetImportRequestArgs) *git.GitImportRequest); ok {
		r0 = returnFunc(context1, getImportRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitImportRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetImportRequestArgs) error); ok {
		r1 = returnFunc(context1, getImportRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetImportRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImportRequest'
type Client_GetImportRequest_Call struct {
	*mock.Call
}

// GetImportRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - getImportRequestArgs git.GetImportRequestArgs
func (_e *Client_Expecter) GetImportRequest(context1 interface{}, getImportRequestArgs interface{}) *Client_GetImportRequest_Call {
	return &Client_GetImportRequest_Call{Call: _e.mock.On("GetImportRequest", context1, getImportRequestArgs)}
}

func (_c *Client_GetImportRequest_Call) Run(run func(context1 context.Context, getImportRequestArgs git.GetImportRequestArgs)) *Client_GetImportRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetImportRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetImportRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetImportRequest_Call) Return(gitImportRequest *git.GitImportRequest, err error) *Client_GetImportRequest_Call {
	_c.Call.Return(gitImportRequest, err)
	return _c
}

func (_c *Client_GetImportRequest_Call) RunAndReturn(run func(context1 context.Context, getImportRequestArgs git.GetImportRequestArgs) (*git.GitImportRequest, error)) *Client_GetImportRequest_Call {
	_c.Call.Return(run)
	return _c
}

// GetItem provides a mock function for the type Client
func (_mock *Client) GetItem(context1 context.Context, getItemArgs git.GetItemArgs) (*git.GitItem, error) {
	ret := _mock.Called(context1, getItemArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetItem")
	}

	var r0 *git.GitItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemArgs) (*git.GitItem, error)); ok {
		return returnFunc(context1, getItemArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemArgs) *git.GitItem); ok {
		r0 = returnFunc(context1, getItemArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetItemArgs) error); ok {
		r1 = returnFunc(context1, getItemArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItem'
type Client_GetItem_Call struct {
	*mock.Call
}

// GetItem is a helper method to define mock.On call
//   - context1 context.Context
//   - getItemArgs git.GetItemArgs
func (_e *Client_Expecter) GetItem(context1 interface{}, getItemArgs interface{}) *Client_GetItem_Call {
	return &Client_GetItem_Call{Call: _e.mock.On("GetItem", context1, getItemArgs)}
}

func (_c *Client_GetItem_Call) Run(run func(context1 context.Context, getItemArgs git.GetItemArgs)) *Client_GetItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetItemArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetItemArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetItem_Call) Return(gitItem *git.GitItem, err error) *Client_GetItem_Call {
	_c.Call.Return(gitItem, err)
	return _c
}

func (_c *Client_GetItem_Call) RunAndReturn(run func(context1 context.Context, getItemArgs git.GetItemArgs) (*git.GitItem, error)) *Client_GetItem_Call {
	_c.Call.Return(run)
	return _c
}

// GetItemContent provides a mock function for the type Client
func (_mock *Client) GetItemContent(context1 context.Context, getItemContentArgs git.GetItemContentArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getItemContentArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetItemContent")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemContentArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getItemContentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemContentArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getItemContentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetItemContentArgs) error); ok {
		r1 = returnFunc(context1, getItemContentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetItemContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItemContent'
type Client_GetItemContent_Call struct {
	*mock.Call
}

// GetItemContent is a helper method to define mock.On call
//   - context1 context.Context
//   - getItemContentArgs git.GetItemContentArgs
func (_e *Client_Expecter) GetItemContent(context1 interface{}, getItemContentArgs interface{}) *Client_GetItemContent_Call {
	return &Client_GetItemContent_Call{Call: _e.mock.On("GetItemContent", context1, getItemContentArgs)}
}

func (_c *Client_GetItemContent_Call) Run(run func(context1 context.Context, getItemContentArgs git.GetItemContentArgs)) *Client_GetItemContent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetItemContentArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetItemContentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetItemContent_Call) Return(readCloser io.ReadCloser, err error) *Client_GetItemContent_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetItemContent_Call) RunAndReturn(run func(context1 context.Context, getItemContentArgs git.GetItemContentArgs) (io.ReadCloser, error)) *Client_GetItemContent_Call {
	_c.Call.Return(run)
	return _c
}

// GetItemText provides a mock function for the type Client
func (_mock *Client) GetItemText(context1 context.Context, getItemTextArgs git.GetItemTextArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getItemTextArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetItemText")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemTextArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getItemTextArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemTextArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getItemTextArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetItemTextArgs) error); ok {
		r1 = returnFunc(context1, getItemTextArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetItemText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItemText'
type Client_GetItemText_Call struct {
	*mock.Call
}

// GetItemText is a helper method to define mock.On call
//   - context1 context.Context
//   - getItemTextArgs git.GetItemTextArgs
func (_e *Client_Expecter) GetItemText(context1 interface{}, getItemTextArgs interface{}) *Client_GetItemText_Call {
	return &Client_GetItemText_Call{Call: _e.mock.On("GetItemText", context1, getItemTextArgs)}
}

func (_c *Client_GetItemText_Call) Run(run func(context1 context.Context, getItemTextArgs git.GetItemTextArgs)) *Client_GetItemText_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetItemTextArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetItemTextArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetItemText_Call) Return(readCloser io.ReadCloser, err error) *Client_GetItemText_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetItemText_Call) RunAndReturn(run func(context1 context.Context, getItemTextArgs git.GetItemTextArgs) (io.ReadCloser, error)) *Client_GetItemText_Call {
	_c.Call.Return(run)
	return _c
}

// GetItemZip provides a mock function for the type Client
func (_mock *Client) GetItemZip(context1 context.Context, getItemZipArgs git.GetItemZipArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getItemZipArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetItemZip")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemZipArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getItemZipArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemZipArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getItemZipArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetItemZipArgs) error); ok {
		r1 = returnFunc(context1, getItemZipArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetItemZip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItemZip'
type Client_GetItemZip_Call struct {
	*mock.Call
}

// GetItemZip is a helper method to define mock.On call
//   - context1 context.Context
//   - getItemZipArgs git.GetItemZipArgs
func (_e *Client_Expecter) GetItemZip(context1 interface{}, getItemZipArgs interface{}) *Client_GetItemZip_Call {
	return &Client_GetItemZip_Call{Call: _e.mock.On("GetItemZip", context1, getItemZipArgs)}
}

func (_c *Client_GetItemZip_Call) Run(run func(context1 context.Context, getItemZipArgs git.GetItemZipArgs)) *Client_GetItemZip_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetItemZipArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetItemZipArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetItemZip_Call) Return(readCloser io.ReadCloser, err error) *Client_GetItemZip_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetItemZip_Call) RunAndReturn(run func(context1 context.Context, getItemZipArgs git.GetItemZipArgs) (io.ReadCloser, error)) *Client_GetItemZip_Call {
	_c.Call.Return(run)
	return _c
}

// GetItems provides a mock function for the type Client
func (_mock *Client) GetItems(context1 context.Context, getItemsArgs git.GetItemsArgs) (*[]git.GitItem, error) {
	ret := _mock.Called(context1, getItemsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetItems")
	}

	var r0 *[]git.GitItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemsArgs) (*[]git.GitItem, error)); ok {
		return returnFunc(context1, getItemsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemsArgs) *[]git.GitItem); ok {
		r0 = returnFunc(context1, getItemsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetItemsArgs) error); ok {
		r1 = returnFunc(context1, getItemsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItems'
type Client_GetItems_Call struct {
	*mock.Call
}

// GetItems is a helper method to define mock.On call
//   - context1 context.Context
//   - getItemsArgs git.GetItemsArgs
func (_e *Client_Expecter) GetItems(context1 interface{}, getItemsArgs interface{}) *Client_GetItems_Call {
	return &Client_GetItems_Call{Call: _e.mock.On("GetItems", context1, getItemsArgs)}
}

func (_c *Client_GetItems_Call) Run(run func(context1 context.Context, getItemsArgs git.GetItemsArgs)) *Client_GetItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetItemsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetItemsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetItems_Call) Return(gitItems *[]git.GitItem, err error) *Client_GetItems_Call {
	_c.Call.Return(gitItems, err)
	return _c
}

func (_c *Client_GetItems_Call) RunAndReturn(run func(context1 context.Context, getItemsArgs git.GetItemsArgs) (*[]git.GitItem, error)) *Client_GetItems_Call {
	_c.Call.Return(run)
	return _c
}

// GetItemsBatch provides a mock function for the type Client
func (_mock *Client) GetItemsBatch(context1 context.Context, getItemsBatchArgs git.GetItemsBatchArgs) (*[][]git.GitItem, error) {
	ret := _mock.Called(context1, getItemsBatchArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetItemsBatch")
	}

	var r0 *[][]git.GitItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemsBatchArgs) (*[][]git.GitItem, error)); ok {
		return returnFunc(context1, getItemsBatchArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetItemsBatchArgs) *[][]git.GitItem); ok {
		r0 = returnFunc(context1, getItemsBatchArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[][]git.GitItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetItemsBatchArgs) error); ok {
		r1 = returnFunc(context1, getItemsBatchArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetItemsBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItemsBatch'
type Client_GetItemsBatch_Call struct {
	*mock.Call
}

// GetItemsBatch is a helper method to define mock.On call
//   - context1 context.Context
//   - getItemsBatchArgs git.GetItemsBatchArgs
func (_e *Client_Expecter) GetItemsBatch(context1 interface{}, getItemsBatchArgs interface{}) *Client_GetItemsBatch_Call {
	return &Client_GetItemsBatch_Call{Call: _e.mock.On("GetItemsBatch", context1, getItemsBatchArgs)}
}

func (_c *Client_GetItemsBatch_Call) Run(run func(context1 context.Context, getItemsBatchArgs git.GetItemsBatchArgs)) *Client_GetItemsBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetItemsBatchArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetItemsBatchArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetItemsBatch_Call) Return(gitItemss *[][]git.GitItem, err error) *Client_GetItemsBatch_Call {
	_c.Call.Return(gitItemss, err)
	return _c
}

func (_c *Client_GetItemsBatch_Call) RunAndReturn(run func(context1 context.Context, getItemsBatchArgs git.GetItemsBatchArgs) (*[][]git.GitItem, error)) *Client_GetItemsBatch_Call {
	_c.Call.Return(run)
	return _c
}

// GetLikes provides a mock function for the type Client
func (_mock *Client) GetLikes(context1 context.Context, getLikesArgs git.GetLikesArgs) (*[]webapi.IdentityRef, error) {
	ret := _mock.Called(context1, getLikesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetLikes")
	}

	var r0 *[]webapi.IdentityRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetLikesArgs) (*[]webapi.IdentityRef, error)); ok {
		return returnFunc(context1, getLikesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetLikesArgs) *[]webapi.IdentityRef); ok {
		r0 = returnFunc(context1, getLikesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]webapi.IdentityRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetLikesArgs) error); ok {
		r1 = returnFunc(context1, getLikesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetLikes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLikes'
type Client_GetLikes_Call struct {
	*mock.Call
}

// GetLikes is a helper method to define mock.On call
//   - context1 context.Context
//   - getLikesArgs git.GetLikesArgs
func (_e *Client_Expecter) GetLikes(context1 interface{}, getLikesArgs interface{}) *Client_GetLikes_Call {
	return &Client_GetLikes_Call{Call: _e.mock.On("GetLikes", context1, getLikesArgs)}
}

func (_c *Client_GetLikes_Call) Run(run func(context1 context.Context, getLikesArgs git.GetLikesArgs)) *Client_GetLikes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetLikesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetLikesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetLikes_Call) Return(identityRefs *[]webapi.IdentityRef, err error) *Client_GetLikes_Call {
	_c.Call.Return(identityRefs, err)
	return _c
}

func (_c *Client_GetLikes_Call) RunAndReturn(run func(context1 context.Context, getLikesArgs git.GetLikesArgs) (*[]webapi.IdentityRef, error)) *Client_GetLikes_Call {
	_c.Call.Return(run)
	return _c
}

// GetMergeBases provides a mock function for the type Client
func (_mock *Client) GetMergeBases(context1 context.Context, getMergeBasesArgs git.GetMergeBasesArgs) (*[]git.GitCommitRef, error) {
	ret := _mock.Called(context1, getMergeBasesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetMergeBases")
	}

	var r0 *[]git.GitCommitRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetMergeBasesArgs) (*[]git.GitCommitRef, error)); ok {
		return returnFunc(context1, getMergeBasesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetMergeBasesArgs) *[]git.GitCommitRef); ok {
		r0 = returnFunc(context1, getMergeBasesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetMergeBasesArgs) error); ok {
		r1 = returnFunc(context1, getMergeBasesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetMergeBases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMergeBases'
type Client_GetMergeBases_Call struct {
	*mock.Call
}

// GetMergeBases is a helper method to define mock.On call
//   - context1 context.Context
//   - getMergeBasesArgs git.GetMergeBasesArgs
func (_e *Client_Expecter) GetMergeBases(context1 interface{}, getMergeBasesArgs interface{}) *Client_GetMergeBases_Call {
	return &Client_GetMergeBases_Call{Call: _e.mock.On("GetMergeBases", context1, getMergeBasesArgs)}
}

func (_c *Client_GetMergeBases_Call) Run(run func(context1 context.Context, getMergeBasesArgs git.GetMergeBasesArgs)) *Client_GetMergeBases_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetMergeBasesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetMergeBasesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetMergeBases_Call) Return(gitCommitRefs *[]git.GitCommitRef, err error) *Client_GetMergeBases_Call {
	_c.Call.Return(gitCommitRefs, err)
	return _c
}

func (_c *Client_GetMergeBases_Call) RunAndReturn(run func(context1 context.Context, getMergeBasesArgs git.GetMergeBasesArgs) (*[]git.GitCommitRef, error)) *Client_GetMergeBases_Call {
	_c.Call.Return(run)
	return _c
}

// GetMergeRequest provides a mock function for the type Client
func (_mock *Client) GetMergeRequest(context1 context.Context, getMergeRequestArgs git.GetMergeRequestArgs) (*git.GitMerge, error) {
	ret := _mock.Called(context1, getMergeRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetMergeRequest")
	}

	var r0 *git.GitMerge
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetMergeRequestArgs) (*git.GitMerge, error)); ok {
		return returnFunc(context1, getMergeRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetMergeRequestArgs) *git.GitMerge); ok {
		r0 = returnFunc(context1, getMergeRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitMerge)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetMergeRequestArgs) error); ok {
		r1 = returnFunc(context1, getMergeRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetMergeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMergeRequest'
type Client_GetMergeRequest_Call struct {
	*mock.Call
}

// GetMergeRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - getMergeRequestArgs git.GetMergeRequestArgs
func (_e *Client_Expecter) GetMergeRequest(context1 interface{}, getMergeRequestArgs interface{}) *Client_GetMergeRequest_Call {
	return &Client_GetMergeRequest_Call{Call: _e.mock.On("GetMergeRequest", context1, getMergeRequestArgs)}
}

func (_c *Client_GetMergeRequest_Call) Run(run func(context1 context.Context, getMergeRequestArgs git.GetMergeRequestArgs)) *Client_GetMergeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetMergeRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetMergeRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetMergeRequest_Call) Return(gitMerge *git.GitMerge, err error) *Client_GetMergeRequest_Call {
	_c.Call.Return(gitMerge, err)
	return _c
}

func (_c *Client_GetMergeRequest_Call) RunAndReturn(run func(context1 context.Context, getMergeRequestArgs git.GetMergeRequestArgs) (*git.GitMerge, error)) *Client_GetMergeRequest_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermission provides a mock function for the type Client
func (_mock *Client) GetPermission(context1 context.Context, getPermissionArgs git.GetPermissionArgs) (*bool, error) {
	ret := _mock.Called(context1, getPermissionArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPermission")
	}

	var r0 *bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPermissionArgs) (*bool, error)); ok {
		return returnFunc(context1, getPermissionArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPermissionArgs) *bool); ok {
		r0 = returnFunc(context1, getPermissionArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*bool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPermissionArgs) error); ok {
		r1 = returnFunc(context1, getPermissionArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermission'
type Client_GetPermission_Call struct {
	*mock.Call
}

// GetPermission is a helper method to define mock.On call
//   - context1 context.Context
//   - getPermissionArgs git.GetPermissionArgs
func (_e *Client_Expecter) GetPermission(context1 interface{}, getPermissionArgs interface{}) *Client_GetPermission_Call {
	return &Client_GetPermission_Call{Call: _e.mock.On("GetPermission", context1, getPermissionArgs)}
}

func (_c *Client_GetPermission_Call) Run(run func(context1 context.Context, getPermissionArgs git.GetPermissionArgs)) *Client_GetPermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPermissionArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPermissionArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPermission_Call) Return(b *bool, err error) *Client_GetPermission_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *Client_GetPermission_Call) RunAndReturn(run func(context1 context.Context, getPermissionArgs git.GetPermissionArgs) (*bool, error)) *Client_GetPermission_Call {
	_c.Call.Return(run)
	return _c
}

// GetPolicyConfigurations provides a mock function for the type Client
func (_mock *Client) GetPolicyConfigurations(context1 context.Context, getPolicyConfigurationsArgs git.GetPolicyConfigurationsArgs) (*git.GitPolicyConfigurationResponse, error) {
	ret := _mock.Called(context1, getPolicyConfigurationsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPolicyConfigurations")
	}

	var r0 *git.GitPolicyConfigurationResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPolicyConfigurationsArgs) (*git.GitPolicyConfigurationResponse, error)); ok {
		return returnFunc(context1, getPolicyConfigurationsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPolicyConfigurationsArgs) *git.GitPolicyConfigurationResponse); ok {
		r0 = returnFunc(context1, getPolicyConfigurationsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPolicyConfigurationResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPolicyConfigurationsArgs) error); ok {
		r1 = returnFunc(context1, getPolicyConfigurationsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPolicyConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicyConfigurations'
type Client_GetPolicyConfigurations_Call struct {
	*mock.Call
}

// GetPolicyConfigurations is a helper method to define mock.On call
//   - context1 context.Context
//   - getPolicyConfigurationsArgs git.GetPolicyConfigurationsArgs
func (_e *Client_Expecter) GetPolicyConfigurations(context1 interface{}, getPolicyConfigurationsArgs interface{}) *Client_GetPolicyConfigurations_Call {
	return &Client_GetPolicyConfigurations_Call{Call: _e.mock.On("GetPolicyConfigurations", context1, getPolicyConfigurationsArgs)}
}

func (_c *Client_GetPolicyConfigurations_Call) Run(run func(context1 context.Context, getPolicyConfigurationsArgs git.GetPolicyConfigurationsArgs)) *Client_GetPolicyConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPolicyConfigurationsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPolicyConfigurationsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPolicyConfigurations_Call) Return(gitPolicyConfigurationResponse *git.GitPolicyConfigurationResponse, err error) *Client_GetPolicyConfigurations_Call {
	_c.Call.Return(gitPolicyConfigurationResponse, err)
	return _c
}

func (_c *Client_GetPolicyConfigurations_Call) RunAndReturn(run func(context1 context.Context, getPolicyConfigurationsArgs git.GetPolicyConfigurationsArgs) (*git.GitPolicyConfigurationResponse, error)) *Client_GetPolicyConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequest provides a mock function for the type Client
func (_mock *Client) GetPullRequest(context1 context.Context, getPullRequestArgs git.GetPullRequestArgs) (*git.GitPullRequest, error) {
	ret := _mock.Called(context1, getPullRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequest")
	}

	var r0 *git.GitPullRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestArgs) (*git.GitPullRequest, error)); ok {
		return returnFunc(context1, getPullRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestArgs) *git.GitPullRequest); ok {
		r0 = returnFunc(context1, getPullRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequest'
type Client_GetPullRequest_Call struct {
	*mock.Call
}

// GetPullRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestArgs git.GetPullRequestArgs
func (_e *Client_Expecter) GetPullRequest(context1 interface{}, getPullRequestArgs interface{}) *Client_GetPullRequest_Call {
	return &Client_GetPullRequest_Call{Call: _e.mock.On("GetPullRequest", context1, getPullRequestArgs)}
}

func (_c *Client_GetPullRequest_Call) Run(run func(context1 context.Context, getPullRequestArgs git.GetPullRequestArgs)) *Client_GetPullRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequest_Call) Return(gitPullRequest *git.GitPullRequest, err error) *Client_GetPullRequest_Call {
	_c.Call.Return(gitPullRequest, err)
	return _c
}

func (_c *Client_GetPullRequest_Call) RunAndReturn(run func(context1 context.Context, getPullRequestArgs git.GetPullRequestArgs) (*git.GitPullRequest, error)) *Client_GetPullRequest_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestById provides a mock function for the type Client
func (_mock *Client) GetPullRequestById(context1 context.Context, getPullRequestByIdArgs git.GetPullRequestByIdArgs) (*git.GitPullRequest, error) {
	ret := _mock.Called(context1, getPullRequestByIdArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestById")
	}

	var r0 *git.GitPullRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestByIdArgs) (*git.GitPullRequest, error)); ok {
		return returnFunc(context1, getPullRequestByIdArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestByIdArgs) *git.GitPullRequest); ok {
		r0 = returnFunc(context1, getPullRequestByIdArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestByIdArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestByIdArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestById'
type Client_GetPullRequestById_Call struct {
	*mock.Call
}

// GetPullRequestById is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestByIdArgs git.GetPullRequestByIdArgs
func (_e *Client_Expecter) GetPullRequestById(context1 interface{}, getPullRequestByIdArgs interface{}) *Client_GetPullRequestById_Call {
	return &Client_GetPullRequestById_Call{Call: _e.mock.On("GetPullRequestById", context1, getPullRequestByIdArgs)}
}

func (_c *Client_GetPullRequestById_Call) Run(run func(context1 context.Context, getPullRequestByIdArgs git.GetPullRequestByIdArgs)) *Client_GetPullRequestById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestByIdArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestByIdArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestById_Call) Return(gitPullRequest *git.GitPullRequest, err error) *Client_GetPullRequestById_Call {
	_c.Call.Return(gitPullRequest, err)
	return _c
}

func (_c *Client_GetPullRequestById_Call) RunAndReturn(run func(context1 context.Context, getPullRequestByIdArgs git.GetPullRequestByIdArgs) (*git.GitPullRequest, error)) *Client_GetPullRequestById_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestCommits provides a mock function for the type Client
func (_mock *Client) GetPullRequestCommits(context1 context.Context, getPullRequestCommitsArgs git.GetPullRequestCommitsArgs) (*git.GetPullRequestCommitsResponseValue, error) {
	ret := _mock.Called(context1, getPullRequestCommitsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestCommits")
	}

	var r0 *git.GetPullRequestCommitsResponseValue
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestCommitsArgs) (*git.GetPullRequestCommitsResponseValue, error)); ok {
		return returnFunc(context1, getPullRequestCommitsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestCommitsArgs) *git.GetPullRequestCommitsResponseValue); ok {
		r0 = returnFunc(context1, getPullRequestCommitsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GetPullRequestCommitsResponseValue)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestCommitsArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestCommitsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestCommits'
type Client_GetPullRequestCommits_Call struct {
	*mock.Call
}

// GetPullRequestCommits is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestCommitsArgs git.GetPullRequestCommitsArgs
func (_e *Client_Expecter) GetPullRequestCommits(context1 interface{}, getPullRequestCommitsArgs interface{}) *Client_GetPullRequestCommits_Call {
	return &Client_GetPullRequestCommits_Call{Call: _e.mock.On("GetPullRequestCommits", context1, getPullRequestCommitsArgs)}
}

func (_c *Client_GetPullRequestCommits_Call) Run(run func(context1 context.Context, getPullRequestCommitsArgs git.GetPullRequestCommitsArgs)) *Client_GetPullRequestCommits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestCommitsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestCommitsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestCommits_Call) Return(getPullRequestCommitsResponseValue *git.GetPullRequestCommitsResponseValue, err error) *Client_GetPullRequestCommits_Call {
	_c.Call.Return(getPullRequestCommitsResponseValue, err)
	return _c
}

func (_c *Client_GetPullRequestCommits_Call) RunAndReturn(run func(context1 context.Context, getPullRequestCommitsArgs git.GetPullRequestCommitsArgs) (*git.GetPullRequestCommitsResponseValue, error)) *Client_GetPullRequestCommits_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestIteration provides a mock function for the type Client
func (_mock *Client) GetPullRequestIteration(context1 context.Context, getPullRequestIterationArgs git.GetPullRequestIterationArgs) (*git.GitPullRequestIteration, error) {
	ret := _mock.Called(context1, getPullRequestIterationArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestIteration")
	}

	var r0 *git.GitPullRequestIteration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationArgs) (*git.GitPullRequestIteration, error)); ok {
		return returnFunc(context1, getPullRequestIterationArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationArgs) *git.GitPullRequestIteration); ok {
		r0 = returnFunc(context1, getPullRequestIterationArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestIteration)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestIterationArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestIteration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestIteration'
type Client_GetPullRequestIteration_Call struct {
	*mock.Call
}

// GetPullRequestIteration is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestIterationArgs git.GetPullRequestIterationArgs
func (_e *Client_Expecter) GetPullRequestIteration(context1 interface{}, getPullRequestIterationArgs interface{}) *Client_GetPullRequestIteration_Call {
	return &Client_GetPullRequestIteration_Call{Call: _e.mock.On("GetPullRequestIteration", context1, getPullRequestIterationArgs)}
}

func (_c *Client_GetPullRequestIteration_Call) Run(run func(context1 context.Context, getPullRequestIterationArgs git.GetPullRequestIterationArgs)) *Client_GetPullRequestIteration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestIterationArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestIterationArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestIteration_Call) Return(gitPullRequestIteration *git.GitPullRequestIteration, err error) *Client_GetPullRequestIteration_Call {
	_c.Call.Return(gitPullRequestIteration, err)
	return _c
}

func (_c *Client_GetPullRequestIteration_Call) RunAndReturn(run func(context1 context.Context, getPullRequestIterationArgs git.GetPullRequestIterationArgs) (*git.GitPullRequestIteration, error)) *Client_GetPullRequestIteration_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestIterationChanges provides a mock function for the type Client
func (_mock *Client) GetPullRequestIterationChanges(context1 context.Context, getPullRequestIterationChangesArgs git.GetPullRequestIterationChangesArgs) (*git.GitPullRequestIterationChanges, error) {
	ret := _mock.Called(context1, getPullRequestIterationChangesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestIterationChanges")
	}

	var r0 *git.GitPullRequestIterationChanges
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationChangesArgs) (*git.GitPullRequestIterationChanges, error)); ok {
		return returnFunc(context1, getPullRequestIterationChangesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationChangesArgs) *git.GitPullRequestIterationChanges); ok {
		r0 = returnFunc(context1, getPullRequestIterationChangesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestIterationChanges)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationChangesArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestIterationChangesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestIterationChanges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestIterationChanges'
type Client_GetPullRequestIterationChanges_Call struct {
	*mock.Call
}

// GetPullRequestIterationChanges is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestIterationChangesArgs git.GetPullRequestIterationChangesArgs
func (_e *Client_Expecter) GetPullRequestIterationChanges(context1 interface{}, getPullRequestIterationChangesArgs interface{}) *Client_GetPullRequestIterationChanges_Call {
	return &Client_GetPullRequestIterationChanges_Call{Call: _e.mock.On("GetPullRequestIterationChanges", context1, getPullRequestIterationChangesArgs)}
}

func (_c *Client_GetPullRequestIterationChanges_Call) Run(run func(context1 context.Context, getPullRequestIterationChangesArgs git.GetPullRequestIterationChangesArgs)) *Client_GetPullRequestIterationChanges_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestIterationChangesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestIterationChangesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestIterationChanges_Call) Return(gitPullRequestIterationChanges *git.GitPullRequestIterationChanges, err error) *Client_GetPullRequestIterationChanges_Call {
	_c.Call.Return(gitPullRequestIterationChanges, err)
	return _c
}

func (_c *Client_GetPullRequestIterationChanges_Call) RunAndReturn(run func(context1 context.Context, getPullRequestIterationChangesArgs git.GetPullRequestIterationChangesArgs) (*git.GitPullRequestIterationChanges, error)) *Client_GetPullRequestIterationChanges_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestIterationCommits provides a mock function for the type Client
func (_mock *Client) GetPullRequestIterationCommits(context1 context.Context, getPullRequestIterationCommitsArgs git.GetPullRequestIterationCommitsArgs) (*[]git.GitCommitRef, error) {
	ret := _mock.Called(context1, getPullRequestIterationCommitsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestIterationCommits")
	}

	var r0 *[]git.GitCommitRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationCommitsArgs) (*[]git.GitCommitRef, error)); ok {
		return returnFunc(context1, getPullRequestIterationCommitsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationCommitsArgs) *[]git.GitCommitRef); ok {
		r0 = returnFunc(context1, getPullRequestIterationCommitsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationCommitsArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestIterationCommitsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestIterationCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestIterationCommits'
type Client_GetPullRequestIterationCommits_Call struct {
	*mock.Call
}

// GetPullRequestIterationCommits is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestIterationCommitsArgs git.GetPullRequestIterationCommitsArgs
func (_e *Client_Expecter) GetPullRequestIterationCommits(context1 interface{}, getPullRequestIterationCommitsArgs interface{}) *Client_GetPullRequestIterationCommits_Call {
	return &Client_GetPullRequestIterationCommits_Call{Call: _e.mock.On("GetPullRequestIterationCommits", context1, getPullRequestIterationCommitsArgs)}
}

func (_c *Client_GetPullRequestIterationCommits_Call) Run(run func(context1 context.Context, getPullRequestIterationCommitsArgs git.GetPullRequestIterationCommitsArgs)) *Client_GetPullRequestIterationCommits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestIterationCommitsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestIterationCommitsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestIterationCommits_Call) Return(gitCommitRefs *[]git.GitCommitRef, err error) *Client_GetPullRequestIterationCommits_Call {
	_c.Call.Return(gitCommitRefs, err)
	return _c
}

func (_c *Client_GetPullRequestIterationCommits_Call) RunAndReturn(run func(context1 context.Context, getPullRequestIterationCommitsArgs git.GetPullRequestIterationCommitsArgs) (*[]git.GitCommitRef, error)) *Client_GetPullRequestIterationCommits_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestIterationStatus provides a mock function for the type Client
func (_mock *Client) GetPullRequestIterationStatus(context1 context.Context, getPullRequestIterationStatusArgs git.GetPullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _mock.Called(context1, getPullRequestIterationStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestIterationStatus")
	}

	var r0 *git.GitPullRequestStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error)); ok {
		return returnFunc(context1, getPullRequestIterationStatusArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = returnFunc(context1, getPullRequestIterationStatusArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationStatusArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestIterationStatusArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestIterationStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestIterationStatus'
type Client_GetPullRequestIterationStatus_Call struct {
	*mock.Call
}

// GetPullRequestIterationStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestIterationStatusArgs git.GetPullRequestIterationStatusArgs
func (_e *Client_Expecter) GetPullRequestIterationStatus(context1 interface{}, getPullRequestIterationStatusArgs interface{}) *Client_GetPullRequestIterationStatus_Call {
	return &Client_GetPullRequestIterationStatus_Call{Call: _e.mock.On("GetPullRequestIterationStatus", context1, getPullRequestIterationStatusArgs)}
}

func (_c *Client_GetPullRequestIterationStatus_Call) Run(run func(context1 context.Context, getPullRequestIterationStatusArgs git.GetPullRequestIterationStatusArgs)) *Client_GetPullRequestIterationStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestIterationStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestIterationStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestIterationStatus_Call) Return(gitPullRequestStatus *git.GitPullRequestStatus, err error) *Client_GetPullRequestIterationStatus_Call {
	_c.Call.Return(gitPullRequestStatus, err)
	return _c
}

func (_c *Client_GetPullRequestIterationStatus_Call) RunAndReturn(run func(context1 context.Context, getPullRequestIterationStatusArgs git.GetPullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error)) *Client_GetPullRequestIterationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestIterationStatuses provides a mock function for the type Client
func (_mock *Client) GetPullRequestIterationStatuses(context1 context.Context, getPullRequestIterationStatusesArgs git.GetPullRequestIterationStatusesArgs) (*[]git.GitPullRequestStatus, error) {
	ret := _mock.Called(context1, getPullRequestIterationStatusesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestIterationStatuses")
	}

	var r0 *[]git.GitPullRequestStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationStatusesArgs) (*[]git.GitPullRequestStatus, error)); ok {
		return returnFunc(context1, getPullRequestIterationStatusesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationStatusesArgs) *[]git.GitPullRequestStatus); ok {
		r0 = returnFunc(context1, getPullRequestIterationStatusesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationStatusesArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestIterationStatusesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestIterationStatuses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestIterationStatuses'
type Client_GetPullRequestIterationStatuses_Call struct {
	*mock.Call
}

// GetPullRequestIterationStatuses is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestIterationStatusesArgs git.GetPullRequestIterationStatusesArgs
func (_e *Client_Expecter) GetPullRequestIterationStatuses(context1 interface{}, getPullRequestIterationStatusesArgs interface{}) *Client_GetPullRequestIterationStatuses_Call {
	return &Client_GetPullRequestIterationStatuses_Call{Call: _e.mock.On("GetPullRequestIterationStatuses", context1, getPullRequestIterationStatusesArgs)}
}

func (_c *Client_GetPullRequestIterationStatuses_Call) Run(run func(context1 context.Context, getPullRequestIterationStatusesArgs git.GetPullRequestIterationStatusesArgs)) *Client_GetPullRequestIterationStatuses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestIterationStatusesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestIterationStatusesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestIterationStatuses_Call) Return(gitPullRequestStatuss *[]git.GitPullRequestStatus, err error) *Client_GetPullRequestIterationStatuses_Call {
	_c.Call.Return(gitPullRequestStatuss, err)
	return _c
}

func (_c *Client_GetPullRequestIterationStatuses_Call) RunAndReturn(run func(context1 context.Context, getPullRequestIterationStatusesArgs git.GetPullRequestIterationStatusesArgs) (*[]git.GitPullRequestStatus, error)) *Client_GetPullRequestIterationStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestIterations provides a mock function for the type Client
func (_mock *Client) GetPullRequestIterations(context1 context.Context, getPullRequestIterationsArgs git.GetPullRequestIterationsArgs) (*[]git.GitPullRequestIteration, error) {
	ret := _mock.Called(context1, getPullRequestIterationsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestIterations")
	}

	var r0 *[]git.GitPullRequestIteration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationsArgs) (*[]git.GitPullRequestIteration, error)); ok {
		return returnFunc(context1, getPullRequestIterationsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestIterationsArgs) *[]git.GitPullRequestIteration); ok {
		r0 = returnFunc(context1, getPullRequestIterationsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestIteration)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestIterationsArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestIterationsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestIterations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestIterations'
type Client_GetPullRequestIterations_Call struct {
	*mock.Call
}

// GetPullRequestIterations is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestIterationsArgs git.GetPullRequestIterationsArgs
func (_e *Client_Expecter) GetPullRequestIterations(context1 interface{}, getPullRequestIterationsArgs interface{}) *Client_GetPullRequestIterations_Call {
	return &Client_GetPullRequestIterations_Call{Call: _e.mock.On("GetPullRequestIterations", context1, getPullRequestIterationsArgs)}
}

func (_c *Client_GetPullRequestIterations_Call) Run(run func(context1 context.Context, getPullRequestIterationsArgs git.GetPullRequestIterationsArgs)) *Client_GetPullRequestIterations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestIterationsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestIterationsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestIterations_Call) Return(gitPullRequestIterations *[]git.GitPullRequestIteration, err error) *Client_GetPullRequestIterations_Call {
	_c.Call.Return(gitPullRequestIterations, err)
	return _c
}

func (_c *Client_GetPullRequestIterations_Call) RunAndReturn(run func(context1 context.Context, getPullRequestIterationsArgs git.GetPullRequestIterationsArgs) (*[]git.GitPullRequestIteration, error)) *Client_GetPullRequestIterations_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestLabel provides a mock function for the type Client
func (_mock *Client) GetPullRequestLabel(context1 context.Context, getPullRequestLabelArgs git.GetPullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
	ret := _mock.Called(context1, getPullRequestLabelArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestLabel")
	}

	var r0 *core.WebApiTagDefinition
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestLabelArgs) (*core.WebApiTagDefinition, error)); ok {
		return returnFunc(context1, getPullRequestLabelArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestLabelArgs) *core.WebApiTagDefinition); ok {
		r0 = returnFunc(context1, getPullRequestLabelArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*core.WebApiTagDefinition)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestLabelArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestLabelArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestLabel'
type Client_GetPullRequestLabel_Call struct {
	*mock.Call
}

// GetPullRequestLabel is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestLabelArgs git.GetPullRequestLabelArgs
func (_e *Client_Expecter) GetPullRequestLabel(context1 interface{}, getPullRequestLabelArgs interface{}) *Client_GetPullRequestLabel_Call {
	return &Client_GetPullRequestLabel_Call{Call: _e.mock.On("GetPullRequestLabel", context1, getPullRequestLabelArgs)}
}

func (_c *Client_GetPullRequestLabel_Call) Run(run func(context1 context.Context, getPullRequestLabelArgs git.GetPullRequestLabelArgs)) *Client_GetPullRequestLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestLabelArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestLabelArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestLabel_Call) Return(webApiTagDefinition *core.WebApiTagDefinition, err error) *Client_GetPullRequestLabel_Call {
	_c.Call.Return(webApiTagDefinition, err)
	return _c
}

func (_c *Client_GetPullRequestLabel_Call) RunAndReturn(run func(context1 context.Context, getPullRequestLabelArgs git.GetPullRequestLabelArgs) (*core.WebApiTagDefinition, error)) *Client_GetPullRequestLabel_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestLabels provides a mock function for the type Client
func (_mock *Client) GetPullRequestLabels(context1 context.Context, getPullRequestLabelsArgs git.GetPullRequestLabelsArgs) (*[]core.WebApiTagDefinition, error) {
	ret := _mock.Called(context1, getPullRequestLabelsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestLabels")
	}

	var r0 *[]core.WebApiTagDefinition
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestLabelsArgs) (*[]core.WebApiTagDefinition, error)); ok {
		return returnFunc(context1, getPullRequestLabelsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestLabelsArgs) *[]core.WebApiTagDefinition); ok {
		r0 = returnFunc(context1, getPullRequestLabelsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]core.WebApiTagDefinition)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestLabelsArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestLabelsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestLabels'
type Client_GetPullRequestLabels_Call struct {
	*mock.Call
}

// GetPullRequestLabels is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestLabelsArgs git.GetPullRequestLabelsArgs
func (_e *Client_Expecter) GetPullRequestLabels(context1 interface{}, getPullRequestLabelsArgs interface{}) *Client_GetPullRequestLabels_Call {
	return &Client_GetPullRequestLabels_Call{Call: _e.mock.On("GetPullRequestLabels", context1, getPullRequestLabelsArgs)}
}

func (_c *Client_GetPullRequestLabels_Call) Run(run func(context1 context.Context, getPullRequestLabelsArgs git.GetPullRequestLabelsArgs)) *Client_GetPullRequestLabels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestLabelsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestLabelsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestLabels_Call) Return(webApiTagDefinitions *[]core.WebApiTagDefinition, err error) *Client_GetPullRequestLabels_Call {
	_c.Call.Return(webApiTagDefinitions, err)
	return _c
}

func (_c *Client_GetPullRequestLabels_Call) RunAndReturn(run func(context1 context.Context, getPullRequestLabelsArgs git.GetPullRequestLabelsArgs) (*[]core.WebApiTagDefinition, error)) *Client_GetPullRequestLabels_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestProperties provides a mock function for the type Client
func (_mock *Client) GetPullRequestProperties(context1 context.Context, getPullRequestPropertiesArgs git.GetPullRequestPropertiesArgs) (interface{}, error) {
	ret := _mock.Called(context1, getPullRequestPropertiesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestProperties")
	}

	var r0 interface{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestPropertiesArgs) (interface{}, error)); ok {
		return returnFunc(context1, getPullRequestPropertiesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestPropertiesArgs) interface{}); ok {
		r0 = returnFunc(context1, getPullRequestPropertiesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestPropertiesArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestPropertiesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestProperties'
type Client_GetPullRequestProperties_Call struct {
	*mock.Call
}

// GetPullRequestProperties is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestPropertiesArgs git.GetPullRequestPropertiesArgs
func (_e *Client_Expecter) GetPullRequestProperties(context1 interface{}, getPullRequestPropertiesArgs interface{}) *Client_GetPullRequestProperties_Call {
	return &Client_GetPullRequestProperties_Call{Call: _e.mock.On("GetPullRequestProperties", context1, getPullRequestPropertiesArgs)}
}

func (_c *Client_GetPullRequestProperties_Call) Run(run func(context1 context.Context, getPullRequestPropertiesArgs git.GetPullRequestPropertiesArgs)) *Client_GetPullRequestProperties_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestPropertiesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestPropertiesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestProperties_Call) Return(ifaceVal interface{}, err error) *Client_GetPullRequestProperties_Call {
	_c.Call.Return(ifaceVal, err)
	return _c
}

func (_c *Client_GetPullRequestProperties_Call) RunAndReturn(run func(context1 context.Context, getPullRequestPropertiesArgs git.GetPullRequestPropertiesArgs) (interface{}, error)) *Client_GetPullRequestProperties_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestQuery provides a mock function for the type Client
func (_mock *Client) GetPullRequestQuery(context1 context.Context, getPullRequestQueryArgs git.GetPullRequestQueryArgs) (*git.GitPullRequestQuery, error) {
	ret := _mock.Called(context1, getPullRequestQueryArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestQuery")
	}

	var r0 *git.GitPullRequestQuery
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestQueryArgs) (*git.GitPullRequestQuery, error)); ok {
		return returnFunc(context1, getPullRequestQueryArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestQueryArgs) *git.GitPullRequestQuery); ok {
		r0 = returnFunc(context1, getPullRequestQueryArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestQuery)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestQueryArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestQueryArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestQuery'
type Client_GetPullRequestQuery_Call struct {
	*mock.Call
}

// GetPullRequestQuery is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestQueryArgs git.GetPullRequestQueryArgs
func (_e *Client_Expecter) GetPullRequestQuery(context1 interface{}, getPullRequestQueryArgs interface{}) *Client_GetPullRequestQuery_Call {
	return &Client_GetPullRequestQuery_Call{Call: _e.mock.On("GetPullRequestQuery", context1, getPullRequestQueryArgs)}
}

func (_c *Client_GetPullRequestQuery_Call) Run(run func(context1 context.Context, getPullRequestQueryArgs git.GetPullRequestQueryArgs)) *Client_GetPullRequestQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestQueryArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestQueryArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestQuery_Call) Return(gitPullRequestQuery *git.GitPullRequestQuery, err error) *Client_GetPullRequestQuery_Call {
	_c.Call.Return(gitPullRequestQuery, err)
	return _c
}

func (_c *Client_GetPullRequestQuery_Call) RunAndReturn(run func(context1 context.Context, getPullRequestQueryArgs git.GetPullRequestQueryArgs) (*git.GitPullRequestQuery, error)) *Client_GetPullRequestQuery_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestReviewer provides a mock function for the type Client
func (_mock *Client) GetPullRequestReviewer(context1 context.Context, getPullRequestReviewerArgs git.GetPullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	ret := _mock.Called(context1, getPullRequestReviewerArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestReviewer")
	}

	var r0 *git.IdentityRefWithVote
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestReviewerArgs) (*git.IdentityRefWithVote, error)); ok {
		return returnFunc(context1, getPullRequestReviewerArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestReviewerArgs) *git.IdentityRefWithVote); ok {
		r0 = returnFunc(context1, getPullRequestReviewerArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.IdentityRefWithVote)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestReviewerArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestReviewerArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestReviewer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestReviewer'
type Client_GetPullRequestReviewer_Call struct {
	*mock.Call
}

// GetPullRequestReviewer is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestReviewerArgs git.GetPullRequestReviewerArgs
func (_e *Client_Expecter) GetPullRequestReviewer(context1 interface{}, getPullRequestReviewerArgs interface{}) *Client_GetPullRequestReviewer_Call {
	return &Client_GetPullRequestReviewer_Call{Call: _e.mock.On("GetPullRequestReviewer", context1, getPullRequestReviewerArgs)}
}

func (_c *Client_GetPullRequestReviewer_Call) Run(run func(context1 context.Context, getPullRequestReviewerArgs git.GetPullRequestReviewerArgs)) *Client_GetPullRequestReviewer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestReviewerArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestReviewerArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestReviewer_Call) Return(identityRefWithVote *git.IdentityRefWithVote, err error) *Client_GetPullRequestReviewer_Call {
	_c.Call.Return(identityRefWithVote, err)
	return _c
}

func (_c *Client_GetPullRequestReviewer_Call) RunAndReturn(run func(context1 context.Context, getPullRequestReviewerArgs git.GetPullRequestReviewerArgs) (*git.IdentityRefWithVote, error)) *Client_GetPullRequestReviewer_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestReviewers provides a mock function for the type Client
func (_mock *Client) GetPullRequestReviewers(context1 context.Context, getPullRequestReviewersArgs git.GetPullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
	ret := _mock.Called(context1, getPullRequestReviewersArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestReviewers")
	}

	var r0 *[]git.IdentityRefWithVote
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error)); ok {
		return returnFunc(context1, getPullRequestReviewersArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestReviewersArgs) *[]git.IdentityRefWithVote); ok {
		r0 = returnFunc(context1, getPullRequestReviewersArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.IdentityRefWithVote)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestReviewersArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestReviewersArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestReviewers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestReviewers'
type Client_GetPullRequestReviewers_Call struct {
	*mock.Call
}

// GetPullRequestReviewers is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestReviewersArgs git.GetPullRequestReviewersArgs
func (_e *Client_Expecter) GetPullRequestReviewers(context1 interface{}, getPullRequestReviewersArgs interface{}) *Client_GetPullRequestReviewers_Call {
	return &Client_GetPullRequestReviewers_Call{Call: _e.mock.On("GetPullRequestReviewers", context1, getPullRequestReviewersArgs)}
}

func (_c *Client_GetPullRequestReviewers_Call) Run(run func(context1 context.Context, getPullRequestReviewersArgs git.GetPullRequestReviewersArgs)) *Client_GetPullRequestReviewers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestReviewersArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestReviewersArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestReviewers_Call) Return(identityRefWithVotes *[]git.IdentityRefWithVote, err error) *Client_GetPullRequestReviewers_Call {
	_c.Call.Return(identityRefWithVotes, err)
	return _c
}

func (_c *Client_GetPullRequestReviewers_Call) RunAndReturn(run func(context1 context.Context, getPullRequestReviewersArgs git.GetPullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error)) *Client_GetPullRequestReviewers_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestStatus provides a mock function for the type Client
func (_mock *Client) GetPullRequestStatus(context1 context.Context, getPullRequestStatusArgs git.GetPullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
	ret := _mock.Called(context1, getPullRequestStatusArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestStatus")
	}

	var r0 *git.GitPullRequestStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestStatusArgs) (*git.GitPullRequestStatus, error)); ok {
		return returnFunc(context1, getPullRequestStatusArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestStatusArgs) *git.GitPullRequestStatus); ok {
		r0 = returnFunc(context1, getPullRequestStatusArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestStatusArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestStatusArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestStatus'
type Client_GetPullRequestStatus_Call struct {
	*mock.Call
}

// GetPullRequestStatus is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestStatusArgs git.GetPullRequestStatusArgs
func (_e *Client_Expecter) GetPullRequestStatus(context1 interface{}, getPullRequestStatusArgs interface{}) *Client_GetPullRequestStatus_Call {
	return &Client_GetPullRequestStatus_Call{Call: _e.mock.On("GetPullRequestStatus", context1, getPullRequestStatusArgs)}
}

func (_c *Client_GetPullRequestStatus_Call) Run(run func(context1 context.Context, getPullRequestStatusArgs git.GetPullRequestStatusArgs)) *Client_GetPullRequestStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestStatusArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestStatusArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestStatus_Call) Return(gitPullRequestStatus *git.GitPullRequestStatus, err error) *Client_GetPullRequestStatus_Call {
	_c.Call.Return(gitPullRequestStatus, err)
	return _c
}

func (_c *Client_GetPullRequestStatus_Call) RunAndReturn(run func(context1 context.Context, getPullRequestStatusArgs git.GetPullRequestStatusArgs) (*git.GitPullRequestStatus, error)) *Client_GetPullRequestStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestStatuses provides a mock function for the type Client
func (_mock *Client) GetPullRequestStatuses(context1 context.Context, getPullRequestStatusesArgs git.GetPullRequestStatusesArgs) (*[]git.GitPullRequestStatus, error) {
	ret := _mock.Called(context1, getPullRequestStatusesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestStatuses")
	}

	var r0 *[]git.GitPullRequestStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestStatusesArgs) (*[]git.GitPullRequestStatus, error)); ok {
		return returnFunc(context1, getPullRequestStatusesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestStatusesArgs) *[]git.GitPullRequestStatus); ok {
		r0 = returnFunc(context1, getPullRequestStatusesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestStatusesArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestStatusesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestStatuses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestStatuses'
type Client_GetPullRequestStatuses_Call struct {
	*mock.Call
}

// GetPullRequestStatuses is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestStatusesArgs git.GetPullRequestStatusesArgs
func (_e *Client_Expecter) GetPullRequestStatuses(context1 interface{}, getPullRequestStatusesArgs interface{}) *Client_GetPullRequestStatuses_Call {
	return &Client_GetPullRequestStatuses_Call{Call: _e.mock.On("GetPullRequestStatuses", context1, getPullRequestStatusesArgs)}
}

func (_c *Client_GetPullRequestStatuses_Call) Run(run func(context1 context.Context, getPullRequestStatusesArgs git.GetPullRequestStatusesArgs)) *Client_GetPullRequestStatuses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestStatusesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestStatusesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestStatuses_Call) Return(gitPullRequestStatuss *[]git.GitPullRequestStatus, err error) *Client_GetPullRequestStatuses_Call {
	_c.Call.Return(gitPullRequestStatuss, err)
	return _c
}

func (_c *Client_GetPullRequestStatuses_Call) RunAndReturn(run func(context1 context.Context, getPullRequestStatusesArgs git.GetPullRequestStatusesArgs) (*[]git.GitPullRequestStatus, error)) *Client_GetPullRequestStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestThread provides a mock function for the type Client
func (_mock *Client) GetPullRequestThread(context1 context.Context, getPullRequestThreadArgs git.GetPullRequestThreadArgs) (*git.GitPullRequestCommentThread, error) {
	ret := _mock.Called(context1, getPullRequestThreadArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestThread")
	}

	var r0 *git.GitPullRequestCommentThread
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestThreadArgs) (*git.GitPullRequestCommentThread, error)); ok {
		return returnFunc(context1, getPullRequestThreadArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestThreadArgs) *git.GitPullRequestCommentThread); ok {
		r0 = returnFunc(context1, getPullRequestThreadArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestCommentThread)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestThreadArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestThreadArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestThread_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestThread'
type Client_GetPullRequestThread_Call struct {
	*mock.Call
}

// GetPullRequestThread is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestThreadArgs git.GetPullRequestThreadArgs
func (_e *Client_Expecter) GetPullRequestThread(context1 interface{}, getPullRequestThreadArgs interface{}) *Client_GetPullRequestThread_Call {
	return &Client_GetPullRequestThread_Call{Call: _e.mock.On("GetPullRequestThread", context1, getPullRequestThreadArgs)}
}

func (_c *Client_GetPullRequestThread_Call) Run(run func(context1 context.Context, getPullRequestThreadArgs git.GetPullRequestThreadArgs)) *Client_GetPullRequestThread_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestThreadArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestThreadArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestThread_Call) Return(gitPullRequestCommentThread *git.GitPullRequestCommentThread, err error) *Client_GetPullRequestThread_Call {
	_c.Call.Return(gitPullRequestCommentThread, err)
	return _c
}

func (_c *Client_GetPullRequestThread_Call) RunAndReturn(run func(context1 context.Context, getPullRequestThreadArgs git.GetPullRequestThreadArgs) (*git.GitPullRequestCommentThread, error)) *Client_GetPullRequestThread_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestWorkItemRefs provides a mock function for the type Client
func (_mock *Client) GetPullRequestWorkItemRefs(context1 context.Context, getPullRequestWorkItemRefsArgs git.GetPullRequestWorkItemRefsArgs) (*[]webapi.ResourceRef, error) {
	ret := _mock.Called(context1, getPullRequestWorkItemRefsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestWorkItemRefs")
	}

	var r0 *[]webapi.ResourceRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestWorkItemRefsArgs) (*[]webapi.ResourceRef, error)); ok {
		return returnFunc(context1, getPullRequestWorkItemRefsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestWorkItemRefsArgs) *[]webapi.ResourceRef); ok {
		r0 = returnFunc(context1, getPullRequestWorkItemRefsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]webapi.ResourceRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestWorkItemRefsArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestWorkItemRefsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestWorkItemRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestWorkItemRefs'
type Client_GetPullRequestWorkItemRefs_Call struct {
	*mock.Call
}

// GetPullRequestWorkItemRefs is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestWorkItemRefsArgs git.GetPullRequestWorkItemRefsArgs
func (_e *Client_Expecter) GetPullRequestWorkItemRefs(context1 interface{}, getPullRequestWorkItemRefsArgs interface{}) *Client_GetPullRequestWorkItemRefs_Call {
	return &Client_GetPullRequestWorkItemRefs_Call{Call: _e.mock.On("GetPullRequestWorkItemRefs", context1, getPullRequestWorkItemRefsArgs)}
}

func (_c *Client_GetPullRequestWorkItemRefs_Call) Run(run func(context1 context.Context, getPullRequestWorkItemRefsArgs git.GetPullRequestWorkItemRefsArgs)) *Client_GetPullRequestWorkItemRefs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestWorkItemRefsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestWorkItemRefsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestWorkItemRefs_Call) Return(resourceRefs *[]webapi.ResourceRef, err error) *Client_GetPullRequestWorkItemRefs_Call {
	_c.Call.Return(resourceRefs, err)
	return _c
}

func (_c *Client_GetPullRequestWorkItemRefs_Call) RunAndReturn(run func(context1 context.Context, getPullRequestWorkItemRefsArgs git.GetPullRequestWorkItemRefsArgs) (*[]webapi.ResourceRef, error)) *Client_GetPullRequestWorkItemRefs_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequests provides a mock function for the type Client
func (_mock *Client) GetPullRequests(context1 context.Context, getPullRequestsArgs git.GetPullRequestsArgs) (*[]git.GitPullRequest, error) {
	ret := _mock.Called(context1, getPullRequestsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequests")
	}

	var r0 *[]git.GitPullRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestsArgs) (*[]git.GitPullRequest, error)); ok {
		return returnFunc(context1, getPullRequestsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestsArgs) *[]git.GitPullRequest); ok {
		r0 = returnFunc(context1, getPullRequestsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestsArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequests'
type Client_GetPullRequests_Call struct {
	*mock.Call
}

// GetPullRequests is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestsArgs git.GetPullRequestsArgs
func (_e *Client_Expecter) GetPullRequests(context1 interface{}, getPullRequestsArgs interface{}) *Client_GetPullRequests_Call {
	return &Client_GetPullRequests_Call{Call: _e.mock.On("GetPullRequests", context1, getPullRequestsArgs)}
}

func (_c *Client_GetPullRequests_Call) Run(run func(context1 context.Context, getPullRequestsArgs git.GetPullRequestsArgs)) *Client_GetPullRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequests_Call) Return(gitPullRequests *[]git.GitPullRequest, err error) *Client_GetPullRequests_Call {
	_c.Call.Return(gitPullRequests, err)
	return _c
}

func (_c *Client_GetPullRequests_Call) RunAndReturn(run func(context1 context.Context, getPullRequestsArgs git.GetPullRequestsArgs) (*[]git.GitPullRequest, error)) *Client_GetPullRequests_Call {
	_c.Call.Return(run)
	return _c
}

// GetPullRequestsByProject provides a mock function for the type Client
func (_mock *Client) GetPullRequestsByProject(context1 context.Context, getPullRequestsByProjectArgs git.GetPullRequestsByProjectArgs) (*[]git.GitPullRequest, error) {
	ret := _mock.Called(context1, getPullRequestsByProjectArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPullRequestsByProject")
	}

	var r0 *[]git.GitPullRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestsByProjectArgs) (*[]git.GitPullRequest, error)); ok {
		return returnFunc(context1, getPullRequestsByProjectArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPullRequestsByProjectArgs) *[]git.GitPullRequest); ok {
		r0 = returnFunc(context1, getPullRequestsByProjectArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPullRequestsByProjectArgs) error); ok {
		r1 = returnFunc(context1, getPullRequestsByProjectArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPullRequestsByProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPullRequestsByProject'
type Client_GetPullRequestsByProject_Call struct {
	*mock.Call
}

// GetPullRequestsByProject is a helper method to define mock.On call
//   - context1 context.Context
//   - getPullRequestsByProjectArgs git.GetPullRequestsByProjectArgs
func (_e *Client_Expecter) GetPullRequestsByProject(context1 interface{}, getPullRequestsByProjectArgs interface{}) *Client_GetPullRequestsByProject_Call {
	return &Client_GetPullRequestsByProject_Call{Call: _e.mock.On("GetPullRequestsByProject", context1, getPullRequestsByProjectArgs)}
}

func (_c *Client_GetPullRequestsByProject_Call) Run(run func(context1 context.Context, getPullRequestsByProjectArgs git.GetPullRequestsByProjectArgs)) *Client_GetPullRequestsByProject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPullRequestsByProjectArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPullRequestsByProjectArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPullRequestsByProject_Call) Return(gitPullRequests *[]git.GitPullRequest, err error) *Client_GetPullRequestsByProject_Call {
	_c.Call.Return(gitPullRequests, err)
	return _c
}

func (_c *Client_GetPullRequestsByProject_Call) RunAndReturn(run func(context1 context.Context, getPullRequestsByProjectArgs git.GetPullRequestsByProjectArgs) (*[]git.GitPullRequest, error)) *Client_GetPullRequestsByProject_Call {
	_c.Call.Return(run)
	return _c
}

// GetPush provides a mock function for the type Client
func (_mock *Client) GetPush(context1 context.Context, getPushArgs git.GetPushArgs) (*git.GitPush, error) {
	ret := _mock.Called(context1, getPushArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPush")
	}

	var r0 *git.GitPush
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPushArgs) (*git.GitPush, error)); ok {
		return returnFunc(context1, getPushArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPushArgs) *git.GitPush); ok {
		r0 = returnFunc(context1, getPushArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPush)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPushArgs) error); ok {
		r1 = returnFunc(context1, getPushArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPush'
type Client_GetPush_Call struct {
	*mock.Call
}

// GetPush is a helper method to define mock.On call
//   - context1 context.Context
//   - getPushArgs git.GetPushArgs
func (_e *Client_Expecter) GetPush(context1 interface{}, getPushArgs interface{}) *Client_GetPush_Call {
	return &Client_GetPush_Call{Call: _e.mock.On("GetPush", context1, getPushArgs)}
}

func (_c *Client_GetPush_Call) Run(run func(context1 context.Context, getPushArgs git.GetPushArgs)) *Client_GetPush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPushArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPushArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPush_Call) Return(gitPush *git.GitPush, err error) *Client_GetPush_Call {
	_c.Call.Return(gitPush, err)
	return _c
}

func (_c *Client_GetPush_Call) RunAndReturn(run func(context1 context.Context, getPushArgs git.GetPushArgs) (*git.GitPush, error)) *Client_GetPush_Call {
	_c.Call.Return(run)
	return _c
}

// GetPushCommits provides a mock function for the type Client
func (_mock *Client) GetPushCommits(context1 context.Context, getPushCommitsArgs git.GetPushCommitsArgs) (*[]git.GitCommitRef, error) {
	ret := _mock.Called(context1, getPushCommitsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPushCommits")
	}

	var r0 *[]git.GitCommitRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPushCommitsArgs) (*[]git.GitCommitRef, error)); ok {
		return returnFunc(context1, getPushCommitsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPushCommitsArgs) *[]git.GitCommitRef); ok {
		r0 = returnFunc(context1, getPushCommitsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitCommitRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPushCommitsArgs) error); ok {
		r1 = returnFunc(context1, getPushCommitsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPushCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushCommits'
type Client_GetPushCommits_Call struct {
	*mock.Call
}

// GetPushCommits is a helper method to define mock.On call
//   - context1 context.Context
//   - getPushCommitsArgs git.GetPushCommitsArgs
func (_e *Client_Expecter) GetPushCommits(context1 interface{}, getPushCommitsArgs interface{}) *Client_GetPushCommits_Call {
	return &Client_GetPushCommits_Call{Call: _e.mock.On("GetPushCommits", context1, getPushCommitsArgs)}
}

func (_c *Client_GetPushCommits_Call) Run(run func(context1 context.Context, getPushCommitsArgs git.GetPushCommitsArgs)) *Client_GetPushCommits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPushCommitsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPushCommitsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPushCommits_Call) Return(gitCommitRefs *[]git.GitCommitRef, err error) *Client_GetPushCommits_Call {
	_c.Call.Return(gitCommitRefs, err)
	return _c
}

func (_c *Client_GetPushCommits_Call) RunAndReturn(run func(context1 context.Context, getPushCommitsArgs git.GetPushCommitsArgs) (*[]git.GitCommitRef, error)) *Client_GetPushCommits_Call {
	_c.Call.Return(run)
	return _c
}

// GetPushes provides a mock function for the type Client
func (_mock *Client) GetPushes(context1 context.Context, getPushesArgs git.GetPushesArgs) (*[]git.GitPush, error) {
	ret := _mock.Called(context1, getPushesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetPushes")
	}

	var r0 *[]git.GitPush
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPushesArgs) (*[]git.GitPush, error)); ok {
		return returnFunc(context1, getPushesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetPushesArgs) *[]git.GitPush); ok {
		r0 = returnFunc(context1, getPushesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPush)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetPushesArgs) error); ok {
		r1 = returnFunc(context1, getPushesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetPushes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushes'
type Client_GetPushes_Call struct {
	*mock.Call
}

// GetPushes is a helper method to define mock.On call
//   - context1 context.Context
//   - getPushesArgs git.GetPushesArgs
func (_e *Client_Expecter) GetPushes(context1 interface{}, getPushesArgs interface{}) *Client_GetPushes_Call {
	return &Client_GetPushes_Call{Call: _e.mock.On("GetPushes", context1, getPushesArgs)}
}

func (_c *Client_GetPushes_Call) Run(run func(context1 context.Context, getPushesArgs git.GetPushesArgs)) *Client_GetPushes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetPushesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetPushesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetPushes_Call) Return(gitPushs *[]git.GitPush, err error) *Client_GetPushes_Call {
	_c.Call.Return(gitPushs, err)
	return _c
}

func (_c *Client_GetPushes_Call) RunAndReturn(run func(context1 context.Context, getPushesArgs git.GetPushesArgs) (*[]git.GitPush, error)) *Client_GetPushes_Call {
	_c.Call.Return(run)
	return _c
}

// GetRecycleBinRepositories provides a mock function for the type Client
func (_mock *Client) GetRecycleBinRepositories(context1 context.Context, getRecycleBinRepositoriesArgs git.GetRecycleBinRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
	ret := _mock.Called(context1, getRecycleBinRepositoriesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRecycleBinRepositories")
	}

	var r0 *[]git.GitDeletedRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRecycleBinRepositoriesArgs) (*[]git.GitDeletedRepository, error)); ok {
		return returnFunc(context1, getRecycleBinRepositoriesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRecycleBinRepositoriesArgs) *[]git.GitDeletedRepository); ok {
		r0 = returnFunc(context1, getRecycleBinRepositoriesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitDeletedRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRecycleBinRepositoriesArgs) error); ok {
		r1 = returnFunc(context1, getRecycleBinRepositoriesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRecycleBinRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecycleBinRepositories'
type Client_GetRecycleBinRepositories_Call struct {
	*mock.Call
}

// GetRecycleBinRepositories is a helper method to define mock.On call
//   - context1 context.Context
//   - getRecycleBinRepositoriesArgs git.GetRecycleBinRepositoriesArgs
func (_e *Client_Expecter) GetRecycleBinRepositories(context1 interface{}, getRecycleBinRepositoriesArgs interface{}) *Client_GetRecycleBinRepositories_Call {
	return &Client_GetRecycleBinRepositories_Call{Call: _e.mock.On("GetRecycleBinRepositories", context1, getRecycleBinRepositoriesArgs)}
}

func (_c *Client_GetRecycleBinRepositories_Call) Run(run func(context1 context.Context, getRecycleBinRepositoriesArgs git.GetRecycleBinRepositoriesArgs)) *Client_GetRecycleBinRepositories_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRecycleBinRepositoriesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRecycleBinRepositoriesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRecycleBinRepositories_Call) Return(gitDeletedRepositorys *[]git.GitDeletedRepository, err error) *Client_GetRecycleBinRepositories_Call {
	_c.Call.Return(gitDeletedRepositorys, err)
	return _c
}

func (_c *Client_GetRecycleBinRepositories_Call) RunAndReturn(run func(context1 context.Context, getRecycleBinRepositoriesArgs git.GetRecycleBinRepositoriesArgs) (*[]git.GitDeletedRepository, error)) *Client_GetRecycleBinRepositories_Call {
	_c.Call.Return(run)
	return _c
}

// GetRefFavorite provides a mock function for the type Client
func (_mock *Client) GetRefFavorite(context1 context.Context, getRefFavoriteArgs git.GetRefFavoriteArgs) (*git.GitRefFavorite, error) {
	ret := _mock.Called(context1, getRefFavoriteArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRefFavorite")
	}

	var r0 *git.GitRefFavorite
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRefFavoriteArgs) (*git.GitRefFavorite, error)); ok {
		return returnFunc(context1, getRefFavoriteArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRefFavoriteArgs) *git.GitRefFavorite); ok {
		r0 = returnFunc(context1, getRefFavoriteArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRefFavorite)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRefFavoriteArgs) error); ok {
		r1 = returnFunc(context1, getRefFavoriteArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRefFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefFavorite'
type Client_GetRefFavorite_Call struct {
	*mock.Call
}

// GetRefFavorite is a helper method to define mock.On call
//   - context1 context.Context
//   - getRefFavoriteArgs git.GetRefFavoriteArgs
func (_e *Client_Expecter) GetRefFavorite(context1 interface{}, getRefFavoriteArgs interface{}) *Client_GetRefFavorite_Call {
	return &Client_GetRefFavorite_Call{Call: _e.mock.On("GetRefFavorite", context1, getRefFavoriteArgs)}
}

func (_c *Client_GetRefFavorite_Call) Run(run func(context1 context.Context, getRefFavoriteArgs git.GetRefFavoriteArgs)) *Client_GetRefFavorite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRefFavoriteArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRefFavoriteArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRefFavorite_Call) Return(gitRefFavorite *git.GitRefFavorite, err error) *Client_GetRefFavorite_Call {
	_c.Call.Return(gitRefFavorite, err)
	return _c
}

func (_c *Client_GetRefFavorite_Call) RunAndReturn(run func(context1 context.Context, getRefFavoriteArgs git.GetRefFavoriteArgs) (*git.GitRefFavorite, error)) *Client_GetRefFavorite_Call {
	_c.Call.Return(run)
	return _c
}

// GetRefFavorites provides a mock function for the type Client
func (_mock *Client) GetRefFavorites(context1 context.Context, getRefFavoritesArgs git.GetRefFavoritesArgs) (*[]git.GitRefFavorite, error) {
	ret := _mock.Called(context1, getRefFavoritesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRefFavorites")
	}

	var r0 *[]git.GitRefFavorite
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRefFavoritesArgs) (*[]git.GitRefFavorite, error)); ok {
		return returnFunc(context1, getRefFavoritesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRefFavoritesArgs) *[]git.GitRefFavorite); ok {
		r0 = returnFunc(context1, getRefFavoritesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRefFavorite)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRefFavoritesArgs) error); ok {
		r1 = returnFunc(context1, getRefFavoritesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRefFavorites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefFavorites'
type Client_GetRefFavorites_Call struct {
	*mock.Call
}

// GetRefFavorites is a helper method to define mock.On call
//   - context1 context.Context
//   - getRefFavoritesArgs git.GetRefFavoritesArgs
func (_e *Client_Expecter) GetRefFavorites(context1 interface{}, getRefFavoritesArgs interface{}) *Client_GetRefFavorites_Call {
	return &Client_GetRefFavorites_Call{Call: _e.mock.On("GetRefFavorites", context1, getRefFavoritesArgs)}
}

func (_c *Client_GetRefFavorites_Call) Run(run func(context1 context.Context, getRefFavoritesArgs git.GetRefFavoritesArgs)) *Client_GetRefFavorites_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRefFavoritesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRefFavoritesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRefFavorites_Call) Return(gitRefFavorites *[]git.GitRefFavorite, err error) *Client_GetRefFavorites_Call {
	_c.Call.Return(gitRefFavorites, err)
	return _c
}

func (_c *Client_GetRefFavorites_Call) RunAndReturn(run func(context1 context.Context, getRefFavoritesArgs git.GetRefFavoritesArgs) (*[]git.GitRefFavorite, error)) *Client_GetRefFavorites_Call {
	_c.Call.Return(run)
	return _c
}

// GetRefs provides a mock function for the type Client
func (_mock *Client) GetRefs(context1 context.Context, getRefsArgs git.GetRefsArgs) (*git.GetRefsResponseValue, error) {
	ret := _mock.Called(context1, getRefsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRefs")
	}

	var r0 *git.GetRefsResponseValue
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRefsArgs) (*git.GetRefsResponseValue, error)); ok {
		return returnFunc(context1, getRefsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRefsArgs) *git.GetRefsResponseValue); ok {
		r0 = returnFunc(context1, getRefsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GetRefsResponseValue)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRefsArgs) error); ok {
		r1 = returnFunc(context1, getRefsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefs'
type Client_GetRefs_Call struct {
	*mock.Call
}

// GetRefs is a helper method to define mock.On call
//   - context1 context.Context
//   - getRefsArgs git.GetRefsArgs
func (_e *Client_Expecter) GetRefs(context1 interface{}, getRefsArgs interface{}) *Client_GetRefs_Call {
	return &Client_GetRefs_Call{Call: _e.mock.On("GetRefs", context1, getRefsArgs)}
}

func (_c *Client_GetRefs_Call) Run(run func(context1 context.Context, getRefsArgs git.GetRefsArgs)) *Client_GetRefs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRefsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRefsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRefs_Call) Return(getRefsResponseValue *git.GetRefsResponseValue, err error) *Client_GetRefs_Call {
	_c.Call.Return(getRefsResponseValue, err)
	return _c
}

func (_c *Client_GetRefs_Call) RunAndReturn(run func(context1 context.Context, getRefsArgs git.GetRefsArgs) (*git.GetRefsResponseValue, error)) *Client_GetRefs_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepositories provides a mock function for the type Client
func (_mock *Client) GetRepositories(context1 context.Context, getRepositoriesArgs git.GetRepositoriesArgs) (*[]git.GitRepository, error) {
	ret := _mock.Called(context1, getRepositoriesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRepositories")
	}

	var r0 *[]git.GitRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRepositoriesArgs) (*[]git.GitRepository, error)); ok {
		return returnFunc(context1, getRepositoriesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRepositoriesArgs) *[]git.GitRepository); ok {
		r0 = returnFunc(context1, getRepositoriesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRepositoriesArgs) error); ok {
		r1 = returnFunc(context1, getRepositoriesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepositories'
type Client_GetRepositories_Call struct {
	*mock.Call
}

// GetRepositories is a helper method to define mock.On call
//   - context1 context.Context
//   - getRepositoriesArgs git.GetRepositoriesArgs
func (_e *Client_Expecter) GetRepositories(context1 interface{}, getRepositoriesArgs interface{}) *Client_GetRepositories_Call {
	return &Client_GetRepositories_Call{Call: _e.mock.On("GetRepositories", context1, getRepositoriesArgs)}
}

func (_c *Client_GetRepositories_Call) Run(run func(context1 context.Context, getRepositoriesArgs git.GetRepositoriesArgs)) *Client_GetRepositories_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRepositoriesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRepositoriesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRepositories_Call) Return(gitRepositorys *[]git.GitRepository, err error) *Client_GetRepositories_Call {
	_c.Call.Return(gitRepositorys, err)
	return _c
}

func (_c *Client_GetRepositories_Call) RunAndReturn(run func(context1 context.Context, getRepositoriesArgs git.GetRepositoriesArgs) (*[]git.GitRepository, error)) *Client_GetRepositories_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepository provides a mock function for the type Client
func (_mock *Client) GetRepository(context1 context.Context, getRepositoryArgs git.GetRepositoryArgs) (*git.GitRepository, error) {
	ret := _mock.Called(context1, getRepositoryArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRepository")
	}

	var r0 *git.GitRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRepositoryArgs) (*git.GitRepository, error)); ok {
		return returnFunc(context1, getRepositoryArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRepositoryArgs) *git.GitRepository); ok {
		r0 = returnFunc(context1, getRepositoryArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRepositoryArgs) error); ok {
		r1 = returnFunc(context1, getRepositoryArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository'
type Client_GetRepository_Call struct {
	*mock.Call
}

// GetRepository is a helper method to define mock.On call
//   - context1 context.Context
//   - getRepositoryArgs git.GetRepositoryArgs
func (_e *Client_Expecter) GetRepository(context1 interface{}, getRepositoryArgs interface{}) *Client_GetRepository_Call {
	return &Client_GetRepository_Call{Call: _e.mock.On("GetRepository", context1, getRepositoryArgs)}
}

func (_c *Client_GetRepository_Call) Run(run func(context1 context.Context, getRepositoryArgs git.GetRepositoryArgs)) *Client_GetRepository_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRepositoryArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRepositoryArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRepository_Call) Return(gitRepository *git.GitRepository, err error) *Client_GetRepository_Call {
	_c.Call.Return(gitRepository, err)
	return _c
}

func (_c *Client_GetRepository_Call) RunAndReturn(run func(context1 context.Context, getRepositoryArgs git.GetRepositoryArgs) (*git.GitRepository, error)) *Client_GetRepository_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepositoryWithParent provides a mock function for the type Client
func (_mock *Client) GetRepositoryWithParent(context1 context.Context, getRepositoryWithParentArgs git.GetRepositoryWithParentArgs) (*git.GitRepository, error) {
	ret := _mock.Called(context1, getRepositoryWithParentArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRepositoryWithParent")
	}

	var r0 *git.GitRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRepositoryWithParentArgs) (*git.GitRepository, error)); ok {
		return returnFunc(context1, getRepositoryWithParentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRepositoryWithParentArgs) *git.GitRepository); ok {
		r0 = returnFunc(context1, getRepositoryWithParentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRepositoryWithParentArgs) error); ok {
		r1 = returnFunc(context1, getRepositoryWithParentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRepositoryWithParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepositoryWithParent'
type Client_GetRepositoryWithParent_Call struct {
	*mock.Call
}

// GetRepositoryWithParent is a helper method to define mock.On call
//   - context1 context.Context
//   - getRepositoryWithParentArgs git.GetRepositoryWithParentArgs
func (_e *Client_Expecter) GetRepositoryWithParent(context1 interface{}, getRepositoryWithParentArgs interface{}) *Client_GetRepositoryWithParent_Call {
	return &Client_GetRepositoryWithParent_Call{Call: _e.mock.On("GetRepositoryWithParent", context1, getRepositoryWithParentArgs)}
}

func (_c *Client_GetRepositoryWithParent_Call) Run(run func(context1 context.Context, getRepositoryWithParentArgs git.GetRepositoryWithParentArgs)) *Client_GetRepositoryWithParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRepositoryWithParentArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRepositoryWithParentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRepositoryWithParent_Call) Return(gitRepository *git.GitRepository, err error) *Client_GetRepositoryWithParent_Call {
	_c.Call.Return(gitRepository, err)
	return _c
}

func (_c *Client_GetRepositoryWithParent_Call) RunAndReturn(run func(context1 context.Context, getRepositoryWithParentArgs git.GetRepositoryWithParentArgs) (*git.GitRepository, error)) *Client_GetRepositoryWithParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetRevert provides a mock function for the type Client
func (_mock *Client) GetRevert(context1 context.Context, getRevertArgs git.GetRevertArgs) (*git.GitRevert, error) {
	ret := _mock.Called(context1, getRevertArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRevert")
	}

	var r0 *git.GitRevert
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRevertArgs) (*git.GitRevert, error)); ok {
		return returnFunc(context1, getRevertArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRevertArgs) *git.GitRevert); ok {
		r0 = returnFunc(context1, getRevertArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRevert)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRevertArgs) error); ok {
		r1 = returnFunc(context1, getRevertArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRevert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRevert'
type Client_GetRevert_Call struct {
	*mock.Call
}

// GetRevert is a helper method to define mock.On call
//   - context1 context.Context
//   - getRevertArgs git.GetRevertArgs
func (_e *Client_Expecter) GetRevert(context1 interface{}, getRevertArgs interface{}) *Client_GetRevert_Call {
	return &Client_GetRevert_Call{Call: _e.mock.On("GetRevert", context1, getRevertArgs)}
}

func (_c *Client_GetRevert_Call) Run(run func(context1 context.Context, getRevertArgs git.GetRevertArgs)) *Client_GetRevert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRevertArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRevertArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRevert_Call) Return(gitRevert *git.GitRevert, err error) *Client_GetRevert_Call {
	_c.Call.Return(gitRevert, err)
	return _c
}

func (_c *Client_GetRevert_Call) RunAndReturn(run func(context1 context.Context, getRevertArgs git.GetRevertArgs) (*git.GitRevert, error)) *Client_GetRevert_Call {
	_c.Call.Return(run)
	return _c
}

// GetRevertForRefName provides a mock function for the type Client
func (_mock *Client) GetRevertForRefName(context1 context.Context, getRevertForRefNameArgs git.GetRevertForRefNameArgs) (*git.GitRevert, error) {
	ret := _mock.Called(context1, getRevertForRefNameArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetRevertForRefName")
	}

	var r0 *git.GitRevert
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRevertForRefNameArgs) (*git.GitRevert, error)); ok {
		return returnFunc(context1, getRevertForRefNameArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetRevertForRefNameArgs) *git.GitRevert); ok {
		r0 = returnFunc(context1, getRevertForRefNameArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRevert)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetRevertForRefNameArgs) error); ok {
		r1 = returnFunc(context1, getRevertForRefNameArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetRevertForRefName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRevertForRefName'
type Client_GetRevertForRefName_Call struct {
	*mock.Call
}

// GetRevertForRefName is a helper method to define mock.On call
//   - context1 context.Context
//   - getRevertForRefNameArgs git.GetRevertForRefNameArgs
func (_e *Client_Expecter) GetRevertForRefName(context1 interface{}, getRevertForRefNameArgs interface{}) *Client_GetRevertForRefName_Call {
	return &Client_GetRevertForRefName_Call{Call: _e.mock.On("GetRevertForRefName", context1, getRevertForRefNameArgs)}
}

func (_c *Client_GetRevertForRefName_Call) Run(run func(context1 context.Context, getRevertForRefNameArgs git.GetRevertForRefNameArgs)) *Client_GetRevertForRefName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetRevertForRefNameArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetRevertForRefNameArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetRevertForRefName_Call) Return(gitRevert *git.GitRevert, err error) *Client_GetRevertForRefName_Call {
	_c.Call.Return(gitRevert, err)
	return _c
}

func (_c *Client_GetRevertForRefName_Call) RunAndReturn(run func(context1 context.Context, getRevertForRefNameArgs git.GetRevertForRefNameArgs) (*git.GitRevert, error)) *Client_GetRevertForRefName_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatuses provides a mock function for the type Client
func (_mock *Client) GetStatuses(context1 context.Context, getStatusesArgs git.GetStatusesArgs) (*[]git.GitStatus, error) {
	ret := _mock.Called(context1, getStatusesArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetStatuses")
	}

	var r0 *[]git.GitStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetStatusesArgs) (*[]git.GitStatus, error)); ok {
		return returnFunc(context1, getStatusesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetStatusesArgs) *[]git.GitStatus); ok {
		r0 = returnFunc(context1, getStatusesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetStatusesArgs) error); ok {
		r1 = returnFunc(context1, getStatusesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetStatuses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatuses'
type Client_GetStatuses_Call struct {
	*mock.Call
}

// GetStatuses is a helper method to define mock.On call
//   - context1 context.Context
//   - getStatusesArgs git.GetStatusesArgs
func (_e *Client_Expecter) GetStatuses(context1 interface{}, getStatusesArgs interface{}) *Client_GetStatuses_Call {
	return &Client_GetStatuses_Call{Call: _e.mock.On("GetStatuses", context1, getStatusesArgs)}
}

func (_c *Client_GetStatuses_Call) Run(run func(context1 context.Context, getStatusesArgs git.GetStatusesArgs)) *Client_GetStatuses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetStatusesArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetStatusesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetStatuses_Call) Return(gitStatuss *[]git.GitStatus, err error) *Client_GetStatuses_Call {
	_c.Call.Return(gitStatuss, err)
	return _c
}

func (_c *Client_GetStatuses_Call) RunAndReturn(run func(context1 context.Context, getStatusesArgs git.GetStatusesArgs) (*[]git.GitStatus, error)) *Client_GetStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// GetSuggestions provides a mock function for the type Client
func (_mock *Client) GetSuggestions(context1 context.Context, getSuggestionsArgs git.GetSuggestionsArgs) (*[]git.GitSuggestion, error) {
	ret := _mock.Called(context1, getSuggestionsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetSuggestions")
	}

	var r0 *[]git.GitSuggestion
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetSuggestionsArgs) (*[]git.GitSuggestion, error)); ok {
		return returnFunc(context1, getSuggestionsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetSuggestionsArgs) *[]git.GitSuggestion); ok {
		r0 = returnFunc(context1, getSuggestionsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitSuggestion)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetSuggestionsArgs) error); ok {
		r1 = returnFunc(context1, getSuggestionsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetSuggestions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSuggestions'
type Client_GetSuggestions_Call struct {
	*mock.Call
}

// GetSuggestions is a helper method to define mock.On call
//   - context1 context.Context
//   - getSuggestionsArgs git.GetSuggestionsArgs
func (_e *Client_Expecter) GetSuggestions(context1 interface{}, getSuggestionsArgs interface{}) *Client_GetSuggestions_Call {
	return &Client_GetSuggestions_Call{Call: _e.mock.On("GetSuggestions", context1, getSuggestionsArgs)}
}

func (_c *Client_GetSuggestions_Call) Run(run func(context1 context.Context, getSuggestionsArgs git.GetSuggestionsArgs)) *Client_GetSuggestions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetSuggestionsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetSuggestionsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetSuggestions_Call) Return(gitSuggestions *[]git.GitSuggestion, err error) *Client_GetSuggestions_Call {
	_c.Call.Return(gitSuggestions, err)
	return _c
}

func (_c *Client_GetSuggestions_Call) RunAndReturn(run func(context1 context.Context, getSuggestionsArgs git.GetSuggestionsArgs) (*[]git.GitSuggestion, error)) *Client_GetSuggestions_Call {
	_c.Call.Return(run)
	return _c
}

// GetThreads provides a mock function for the type Client
func (_mock *Client) GetThreads(context1 context.Context, getThreadsArgs git.GetThreadsArgs) (*[]git.GitPullRequestCommentThread, error) {
	ret := _mock.Called(context1, getThreadsArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetThreads")
	}

	var r0 *[]git.GitPullRequestCommentThread
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetThreadsArgs) (*[]git.GitPullRequestCommentThread, error)); ok {
		return returnFunc(context1, getThreadsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetThreadsArgs) *[]git.GitPullRequestCommentThread); ok {
		r0 = returnFunc(context1, getThreadsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitPullRequestCommentThread)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetThreadsArgs) error); ok {
		r1 = returnFunc(context1, getThreadsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetThreads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetThreads'
type Client_GetThreads_Call struct {
	*mock.Call
}

// GetThreads is a helper method to define mock.On call
//   - context1 context.Context
//   - getThreadsArgs git.GetThreadsArgs
func (_e *Client_Expecter) GetThreads(context1 interface{}, getThreadsArgs interface{}) *Client_GetThreads_Call {
	return &Client_GetThreads_Call{Call: _e.mock.On("GetThreads", context1, getThreadsArgs)}
}

func (_c *Client_GetThreads_Call) Run(run func(context1 context.Context, getThreadsArgs git.GetThreadsArgs)) *Client_GetThreads_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetThreadsArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetThreadsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetThreads_Call) Return(gitPullRequestCommentThreads *[]git.GitPullRequestCommentThread, err error) *Client_GetThreads_Call {
	_c.Call.Return(gitPullRequestCommentThreads, err)
	return _c
}

func (_c *Client_GetThreads_Call) RunAndReturn(run func(context1 context.Context, getThreadsArgs git.GetThreadsArgs) (*[]git.GitPullRequestCommentThread, error)) *Client_GetThreads_Call {
	_c.Call.Return(run)
	return _c
}

// GetTree provides a mock function for the type Client
func (_mock *Client) GetTree(context1 context.Context, getTreeArgs git.GetTreeArgs) (*git.GitTreeRef, error) {
	ret := _mock.Called(context1, getTreeArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetTree")
	}

	var r0 *git.GitTreeRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetTreeArgs) (*git.GitTreeRef, error)); ok {
		return returnFunc(context1, getTreeArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetTreeArgs) *git.GitTreeRef); ok {
		r0 = returnFunc(context1, getTreeArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitTreeRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetTreeArgs) error); ok {
		r1 = returnFunc(context1, getTreeArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetTree_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTree'
type Client_GetTree_Call struct {
	*mock.Call
}

// GetTree is a helper method to define mock.On call
//   - context1 context.Context
//   - getTreeArgs git.GetTreeArgs
func (_e *Client_Expecter) GetTree(context1 interface{}, getTreeArgs interface{}) *Client_GetTree_Call {
	return &Client_GetTree_Call{Call: _e.mock.On("GetTree", context1, getTreeArgs)}
}

func (_c *Client_GetTree_Call) Run(run func(context1 context.Context, getTreeArgs git.GetTreeArgs)) *Client_GetTree_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetTreeArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetTreeArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetTree_Call) Return(gitTreeRef *git.GitTreeRef, err error) *Client_GetTree_Call {
	_c.Call.Return(gitTreeRef, err)
	return _c
}

func (_c *Client_GetTree_Call) RunAndReturn(run func(context1 context.Context, getTreeArgs git.GetTreeArgs) (*git.GitTreeRef, error)) *Client_GetTree_Call {
	_c.Call.Return(run)
	return _c
}

// GetTreeZip provides a mock function for the type Client
func (_mock *Client) GetTreeZip(context1 context.Context, getTreeZipArgs git.GetTreeZipArgs) (io.ReadCloser, error) {
	ret := _mock.Called(context1, getTreeZipArgs)

	if len(ret) == 0 {
		panic("no return value specified for GetTreeZip")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetTreeZipArgs) (io.ReadCloser, error)); ok {
		return returnFunc(context1, getTreeZipArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.GetTreeZipArgs) io.ReadCloser); ok {
		r0 = returnFunc(context1, getTreeZipArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.GetTreeZipArgs) error); ok {
		r1 = returnFunc(context1, getTreeZipArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_GetTreeZip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTreeZip'
type Client_GetTreeZip_Call struct {
	*mock.Call
}

// GetTreeZip is a helper method to define mock.On call
//   - context1 context.Context
//   - getTreeZipArgs git.GetTreeZipArgs
func (_e *Client_Expecter) GetTreeZip(context1 interface{}, getTreeZipArgs interface{}) *Client_GetTreeZip_Call {
	return &Client_GetTreeZip_Call{Call: _e.mock.On("GetTreeZip", context1, getTreeZipArgs)}
}

func (_c *Client_GetTreeZip_Call) Run(run func(context1 context.Context, getTreeZipArgs git.GetTreeZipArgs)) *Client_GetTreeZip_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.GetTreeZipArgs
		if args[1] != nil {
			arg1 = args[1].(git.GetTreeZipArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_GetTreeZip_Call) Return(readCloser io.ReadCloser, err error) *Client_GetTreeZip_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *Client_GetTreeZip_Call) RunAndReturn(run func(context1 context.Context, getTreeZipArgs git.GetTreeZipArgs) (io.ReadCloser, error)) *Client_GetTreeZip_Call {
	_c.Call.Return(run)
	return _c
}

// QueryImportRequests provides a mock function for the type Client
func (_mock *Client) QueryImportRequests(context1 context.Context, queryImportRequestsArgs git.QueryImportRequestsArgs) (*[]git.GitImportRequest, error) {
	ret := _mock.Called(context1, queryImportRequestsArgs)

	if len(ret) == 0 {
		panic("no return value specified for QueryImportRequests")
	}

	var r0 *[]git.GitImportRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.QueryImportRequestsArgs) (*[]git.GitImportRequest, error)); ok {
		return returnFunc(context1, queryImportRequestsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.QueryImportRequestsArgs) *[]git.GitImportRequest); ok {
		r0 = returnFunc(context1, queryImportRequestsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitImportRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.QueryImportRequestsArgs) error); ok {
		r1 = returnFunc(context1, queryImportRequestsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_QueryImportRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryImportRequests'
type Client_QueryImportRequests_Call struct {
	*mock.Call
}

// QueryImportRequests is a helper method to define mock.On call
//   - context1 context.Context
//   - queryImportRequestsArgs git.QueryImportRequestsArgs
func (_e *Client_Expecter) QueryImportRequests(context1 interface{}, queryImportRequestsArgs interface{}) *Client_QueryImportRequests_Call {
	return &Client_QueryImportRequests_Call{Call: _e.mock.On("QueryImportRequests", context1, queryImportRequestsArgs)}
}

func (_c *Client_QueryImportRequests_Call) Run(run func(context1 context.Context, queryImportRequestsArgs git.QueryImportRequestsArgs)) *Client_QueryImportRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.QueryImportRequestsArgs
		if args[1] != nil {
			arg1 = args[1].(git.QueryImportRequestsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_QueryImportRequests_Call) Return(gitImportRequests *[]git.GitImportRequest, err error) *Client_QueryImportRequests_Call {
	_c.Call.Return(gitImportRequests, err)
	return _c
}

func (_c *Client_QueryImportRequests_Call) RunAndReturn(run func(context1 context.Context, queryImportRequestsArgs git.QueryImportRequestsArgs) (*[]git.GitImportRequest, error)) *Client_QueryImportRequests_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreRepositoryFromRecycleBin provides a mock function for the type Client
func (_mock *Client) RestoreRepositoryFromRecycleBin(context1 context.Context, restoreRepositoryFromRecycleBinArgs git.RestoreRepositoryFromRecycleBinArgs) (*git.GitRepository, error) {
	ret := _mock.Called(context1, restoreRepositoryFromRecycleBinArgs)

	if len(ret) == 0 {
		panic("no return value specified for RestoreRepositoryFromRecycleBin")
	}

	var r0 *git.GitRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.RestoreRepositoryFromRecycleBinArgs) (*git.GitRepository, error)); ok {
		return returnFunc(context1, restoreRepositoryFromRecycleBinArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.RestoreRepositoryFromRecycleBinArgs) *git.GitRepository); ok {
		r0 = returnFunc(context1, restoreRepositoryFromRecycleBinArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.RestoreRepositoryFromRecycleBinArgs) error); ok {
		r1 = returnFunc(context1, restoreRepositoryFromRecycleBinArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_RestoreRepositoryFromRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreRepositoryFromRecycleBin'
type Client_RestoreRepositoryFromRecycleBin_Call struct {
	*mock.Call
}

// RestoreRepositoryFromRecycleBin is a helper method to define mock.On call
//   - context1 context.Context
//   - restoreRepositoryFromRecycleBinArgs git.RestoreRepositoryFromRecycleBinArgs
func (_e *Client_Expecter) RestoreRepositoryFromRecycleBin(context1 interface{}, restoreRepositoryFromRecycleBinArgs interface{}) *Client_RestoreRepositoryFromRecycleBin_Call {
	return &Client_RestoreRepositoryFromRecycleBin_Call{Call: _e.mock.On("RestoreRepositoryFromRecycleBin", context1, restoreRepositoryFromRecycleBinArgs)}
}

func (_c *Client_RestoreRepositoryFromRecycleBin_Call) Run(run func(context1 context.Context, restoreRepositoryFromRecycleBinArgs git.RestoreRepositoryFromRecycleBinArgs)) *Client_RestoreRepositoryFromRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.RestoreRepositoryFromRecycleBinArgs
		if args[1] != nil {
			arg1 = args[1].(git.RestoreRepositoryFromRecycleBinArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_RestoreRepositoryFromRecycleBin_Call) Return(gitRepository *git.GitRepository, err error) *Client_RestoreRepositoryFromRecycleBin_Call {
	_c.Call.Return(gitRepository, err)
	return _c
}

func (_c *Client_RestoreRepositoryFromRecycleBin_Call) RunAndReturn(run func(context1 context.Context, restoreRepositoryFromRecycleBinArgs git.RestoreRepositoryFromRecycleBinArgs) (*git.GitRepository, error)) *Client_RestoreRepositoryFromRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// SharePullRequest provides a mock function for the type Client
func (_mock *Client) SharePullRequest(context1 context.Context, sharePullRequestArgs git.SharePullRequestArgs) error {
	ret := _mock.Called(context1, sharePullRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for SharePullRequest")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.SharePullRequestArgs) error); ok {
		r0 = returnFunc(context1, sharePullRequestArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_SharePullRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SharePullRequest'
type Client_SharePullRequest_Call struct {
	*mock.Call
}

// SharePullRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - sharePullRequestArgs git.SharePullRequestArgs
func (_e *Client_Expecter) SharePullRequest(context1 interface{}, sharePullRequestArgs interface{}) *Client_SharePullRequest_Call {
	return &Client_SharePullRequest_Call{Call: _e.mock.On("SharePullRequest", context1, sharePullRequestArgs)}
}

func (_c *Client_SharePullRequest_Call) Run(run func(context1 context.Context, sharePullRequestArgs git.SharePullRequestArgs)) *Client_SharePullRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.SharePullRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.SharePullRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_SharePullRequest_Call) Return(err error) *Client_SharePullRequest_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_SharePullRequest_Call) RunAndReturn(run func(context1 context.Context, sharePullRequestArgs git.SharePullRequestArgs) error) *Client_SharePullRequest_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateComment provides a mock function for the type Client
func (_mock *Client) UpdateComment(context1 context.Context, updateCommentArgs git.UpdateCommentArgs) (*git.Comment, error) {
	ret := _mock.Called(context1, updateCommentArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdateComment")
	}

	var r0 *git.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateCommentArgs) (*git.Comment, error)); ok {
		return returnFunc(context1, updateCommentArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateCommentArgs) *git.Comment); ok {
		r0 = returnFunc(context1, updateCommentArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.Comment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdateCommentArgs) error); ok {
		r1 = returnFunc(context1, updateCommentArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdateComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateComment'
type Client_UpdateComment_Call struct {
	*mock.Call
}

// UpdateComment is a helper method to define mock.On call
//   - context1 context.Context
//   - updateCommentArgs git.UpdateCommentArgs
func (_e *Client_Expecter) UpdateComment(context1 interface{}, updateCommentArgs interface{}) *Client_UpdateComment_Call {
	return &Client_UpdateComment_Call{Call: _e.mock.On("UpdateComment", context1, updateCommentArgs)}
}

func (_c *Client_UpdateComment_Call) Run(run func(context1 context.Context, updateCommentArgs git.UpdateCommentArgs)) *Client_UpdateComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdateCommentArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdateCommentArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdateComment_Call) Return(comment *git.Comment, err error) *Client_UpdateComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *Client_UpdateComment_Call) RunAndReturn(run func(context1 context.Context, updateCommentArgs git.UpdateCommentArgs) (*git.Comment, error)) *Client_UpdateComment_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateImportRequest provides a mock function for the type Client
func (_mock *Client) UpdateImportRequest(context1 context.Context, updateImportRequestArgs git.UpdateImportRequestArgs) (*git.GitImportRequest, error) {
	ret := _mock.Called(context1, updateImportRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdateImportRequest")
	}

	var r0 *git.GitImportRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateImportRequestArgs) (*git.GitImportRequest, error)); ok {
		return returnFunc(context1, updateImportRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateImportRequestArgs) *git.GitImportRequest); ok {
		r0 = returnFunc(context1, updateImportRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitImportRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdateImportRequestArgs) error); ok {
		r1 = returnFunc(context1, updateImportRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdateImportRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateImportRequest'
type Client_UpdateImportRequest_Call struct {
	*mock.Call
}

// UpdateImportRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - updateImportRequestArgs git.UpdateImportRequestArgs
func (_e *Client_Expecter) UpdateImportRequest(context1 interface{}, updateImportRequestArgs interface{}) *Client_UpdateImportRequest_Call {
	return &Client_UpdateImportRequest_Call{Call: _e.mock.On("UpdateImportRequest", context1, updateImportRequestArgs)}
}

func (_c *Client_UpdateImportRequest_Call) Run(run func(context1 context.Context, updateImportRequestArgs git.UpdateImportRequestArgs)) *Client_UpdateImportRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdateImportRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdateImportRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdateImportRequest_Call) Return(gitImportRequest *git.GitImportRequest, err error) *Client_UpdateImportRequest_Call {
	_c.Call.Return(gitImportRequest, err)
	return _c
}

func (_c *Client_UpdateImportRequest_Call) RunAndReturn(run func(context1 context.Context, updateImportRequestArgs git.UpdateImportRequestArgs) (*git.GitImportRequest, error)) *Client_UpdateImportRequest_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePullRequest provides a mock function for the type Client
func (_mock *Client) UpdatePullRequest(context1 context.Context, updatePullRequestArgs git.UpdatePullRequestArgs) (*git.GitPullRequest, error) {
	ret := _mock.Called(context1, updatePullRequestArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePullRequest")
	}

	var r0 *git.GitPullRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestArgs) (*git.GitPullRequest, error)); ok {
		return returnFunc(context1, updatePullRequestArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestArgs) *git.GitPullRequest); ok {
		r0 = returnFunc(context1, updatePullRequestArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequest)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdatePullRequestArgs) error); ok {
		r1 = returnFunc(context1, updatePullRequestArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdatePullRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePullRequest'
type Client_UpdatePullRequest_Call struct {
	*mock.Call
}

// UpdatePullRequest is a helper method to define mock.On call
//   - context1 context.Context
//   - updatePullRequestArgs git.UpdatePullRequestArgs
func (_e *Client_Expecter) UpdatePullRequest(context1 interface{}, updatePullRequestArgs interface{}) *Client_UpdatePullRequest_Call {
	return &Client_UpdatePullRequest_Call{Call: _e.mock.On("UpdatePullRequest", context1, updatePullRequestArgs)}
}

func (_c *Client_UpdatePullRequest_Call) Run(run func(context1 context.Context, updatePullRequestArgs git.UpdatePullRequestArgs)) *Client_UpdatePullRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdatePullRequestArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdatePullRequestArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdatePullRequest_Call) Return(gitPullRequest *git.GitPullRequest, err error) *Client_UpdatePullRequest_Call {
	_c.Call.Return(gitPullRequest, err)
	return _c
}

func (_c *Client_UpdatePullRequest_Call) RunAndReturn(run func(context1 context.Context, updatePullRequestArgs git.UpdatePullRequestArgs) (*git.GitPullRequest, error)) *Client_UpdatePullRequest_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePullRequestIterationStatuses provides a mock function for the type Client
func (_mock *Client) UpdatePullRequestIterationStatuses(context1 context.Context, updatePullRequestIterationStatusesArgs git.UpdatePullRequestIterationStatusesArgs) error {
	ret := _mock.Called(context1, updatePullRequestIterationStatusesArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePullRequestIterationStatuses")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestIterationStatusesArgs) error); ok {
		r0 = returnFunc(context1, updatePullRequestIterationStatusesArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_UpdatePullRequestIterationStatuses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePullRequestIterationStatuses'
type Client_UpdatePullRequestIterationStatuses_Call struct {
	*mock.Call
}

// UpdatePullRequestIterationStatuses is a helper method to define mock.On call
//   - context1 context.Context
//   - updatePullRequestIterationStatusesArgs git.UpdatePullRequestIterationStatusesArgs
func (_e *Client_Expecter) UpdatePullRequestIterationStatuses(context1 interface{}, updatePullRequestIterationStatusesArgs interface{}) *Client_UpdatePullRequestIterationStatuses_Call {
	return &Client_UpdatePullRequestIterationStatuses_Call{Call: _e.mock.On("UpdatePullRequestIterationStatuses", context1, updatePullRequestIterationStatusesArgs)}
}

func (_c *Client_UpdatePullRequestIterationStatuses_Call) Run(run func(context1 context.Context, updatePullRequestIterationStatusesArgs git.UpdatePullRequestIterationStatusesArgs)) *Client_UpdatePullRequestIterationStatuses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdatePullRequestIterationStatusesArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdatePullRequestIterationStatusesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdatePullRequestIterationStatuses_Call) Return(err error) *Client_UpdatePullRequestIterationStatuses_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_UpdatePullRequestIterationStatuses_Call) RunAndReturn(run func(context1 context.Context, updatePullRequestIterationStatusesArgs git.UpdatePullRequestIterationStatusesArgs) error) *Client_UpdatePullRequestIterationStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePullRequestProperties provides a mock function for the type Client
func (_mock *Client) UpdatePullRequestProperties(context1 context.Context, updatePullRequestPropertiesArgs git.UpdatePullRequestPropertiesArgs) (interface{}, error) {
	ret := _mock.Called(context1, updatePullRequestPropertiesArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePullRequestProperties")
	}

	var r0 interface{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestPropertiesArgs) (interface{}, error)); ok {
		return returnFunc(context1, updatePullRequestPropertiesArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestPropertiesArgs) interface{}); ok {
		r0 = returnFunc(context1, updatePullRequestPropertiesArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdatePullRequestPropertiesArgs) error); ok {
		r1 = returnFunc(context1, updatePullRequestPropertiesArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdatePullRequestProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePullRequestProperties'
type Client_UpdatePullRequestProperties_Call struct {
	*mock.Call
}

// UpdatePullRequestProperties is a helper method to define mock.On call
//   - context1 context.Context
//   - updatePullRequestPropertiesArgs git.UpdatePullRequestPropertiesArgs
func (_e *Client_Expecter) UpdatePullRequestProperties(context1 interface{}, updatePullRequestPropertiesArgs interface{}) *Client_UpdatePullRequestProperties_Call {
	return &Client_UpdatePullRequestProperties_Call{Call: _e.mock.On("UpdatePullRequestProperties", context1, updatePullRequestPropertiesArgs)}
}

func (_c *Client_UpdatePullRequestProperties_Call) Run(run func(context1 context.Context, updatePullRequestPropertiesArgs git.UpdatePullRequestPropertiesArgs)) *Client_UpdatePullRequestProperties_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdatePullRequestPropertiesArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdatePullRequestPropertiesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdatePullRequestProperties_Call) Return(ifaceVal interface{}, err error) *Client_UpdatePullRequestProperties_Call {
	_c.Call.Return(ifaceVal, err)
	return _c
}

func (_c *Client_UpdatePullRequestProperties_Call) RunAndReturn(run func(context1 context.Context, updatePullRequestPropertiesArgs git.UpdatePullRequestPropertiesArgs) (interface{}, error)) *Client_UpdatePullRequestProperties_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePullRequestReviewer provides a mock function for the type Client
func (_mock *Client) UpdatePullRequestReviewer(context1 context.Context, updatePullRequestReviewerArgs git.UpdatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
	ret := _mock.Called(context1, updatePullRequestReviewerArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePullRequestReviewer")
	}

	var r0 *git.IdentityRefWithVote
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error)); ok {
		return returnFunc(context1, updatePullRequestReviewerArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestReviewerArgs) *git.IdentityRefWithVote); ok {
		r0 = returnFunc(context1, updatePullRequestReviewerArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.IdentityRefWithVote)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdatePullRequestReviewerArgs) error); ok {
		r1 = returnFunc(context1, updatePullRequestReviewerArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdatePullRequestReviewer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePullRequestReviewer'
type Client_UpdatePullRequestReviewer_Call struct {
	*mock.Call
}

// UpdatePullRequestReviewer is a helper method to define mock.On call
//   - context1 context.Context
//   - updatePullRequestReviewerArgs git.UpdatePullRequestReviewerArgs
func (_e *Client_Expecter) UpdatePullRequestReviewer(context1 interface{}, updatePullRequestReviewerArgs interface{}) *Client_UpdatePullRequestReviewer_Call {
	return &Client_UpdatePullRequestReviewer_Call{Call: _e.mock.On("UpdatePullRequestReviewer", context1, updatePullRequestReviewerArgs)}
}

func (_c *Client_UpdatePullRequestReviewer_Call) Run(run func(context1 context.Context, updatePullRequestReviewerArgs git.UpdatePullRequestReviewerArgs)) *Client_UpdatePullRequestReviewer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdatePullRequestReviewerArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdatePullRequestReviewerArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdatePullRequestReviewer_Call) Return(identityRefWithVote *git.IdentityRefWithVote, err error) *Client_UpdatePullRequestReviewer_Call {
	_c.Call.Return(identityRefWithVote, err)
	return _c
}

func (_c *Client_UpdatePullRequestReviewer_Call) RunAndReturn(run func(context1 context.Context, updatePullRequestReviewerArgs git.UpdatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error)) *Client_UpdatePullRequestReviewer_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePullRequestReviewers provides a mock function for the type Client
func (_mock *Client) UpdatePullRequestReviewers(context1 context.Context, updatePullRequestReviewersArgs git.UpdatePullRequestReviewersArgs) error {
	ret := _mock.Called(context1, updatePullRequestReviewersArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePullRequestReviewers")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestReviewersArgs) error); ok {
		r0 = returnFunc(context1, updatePullRequestReviewersArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_UpdatePullRequestReviewers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePullRequestReviewers'
type Client_UpdatePullRequestReviewers_Call struct {
	*mock.Call
}

// UpdatePullRequestReviewers is a helper method to define mock.On call
//   - context1 context.Context
//   - updatePullRequestReviewersArgs git.UpdatePullRequestReviewersArgs
func (_e *Client_Expecter) UpdatePullRequestReviewers(context1 interface{}, updatePullRequestReviewersArgs interface{}) *Client_UpdatePullRequestReviewers_Call {
	return &Client_UpdatePullRequestReviewers_Call{Call: _e.mock.On("UpdatePullRequestReviewers", context1, updatePullRequestReviewersArgs)}
}

func (_c *Client_UpdatePullRequestReviewers_Call) Run(run func(context1 context.Context, updatePullRequestReviewersArgs git.UpdatePullRequestReviewersArgs)) *Client_UpdatePullRequestReviewers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdatePullRequestReviewersArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdatePullRequestReviewersArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdatePullRequestReviewers_Call) Return(err error) *Client_UpdatePullRequestReviewers_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_UpdatePullRequestReviewers_Call) RunAndReturn(run func(context1 context.Context, updatePullRequestReviewersArgs git.UpdatePullRequestReviewersArgs) error) *Client_UpdatePullRequestReviewers_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePullRequestStatuses provides a mock function for the type Client
func (_mock *Client) UpdatePullRequestStatuses(context1 context.Context, updatePullRequestStatusesArgs git.UpdatePullRequestStatusesArgs) error {
	ret := _mock.Called(context1, updatePullRequestStatusesArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePullRequestStatuses")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdatePullRequestStatusesArgs) error); ok {
		r0 = returnFunc(context1, updatePullRequestStatusesArgs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Client_UpdatePullRequestStatuses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePullRequestStatuses'
type Client_UpdatePullRequestStatuses_Call struct {
	*mock.Call
}

// UpdatePullRequestStatuses is a helper method to define mock.On call
//   - context1 context.Context
//   - updatePullRequestStatusesArgs git.UpdatePullRequestStatusesArgs
func (_e *Client_Expecter) UpdatePullRequestStatuses(context1 interface{}, updatePullRequestStatusesArgs interface{}) *Client_UpdatePullRequestStatuses_Call {
	return &Client_UpdatePullRequestStatuses_Call{Call: _e.mock.On("UpdatePullRequestStatuses", context1, updatePullRequestStatusesArgs)}
}

func (_c *Client_UpdatePullRequestStatuses_Call) Run(run func(context1 context.Context, updatePullRequestStatusesArgs git.UpdatePullRequestStatusesArgs)) *Client_UpdatePullRequestStatuses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdatePullRequestStatusesArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdatePullRequestStatusesArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdatePullRequestStatuses_Call) Return(err error) *Client_UpdatePullRequestStatuses_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Client_UpdatePullRequestStatuses_Call) RunAndReturn(run func(context1 context.Context, updatePullRequestStatusesArgs git.UpdatePullRequestStatusesArgs) error) *Client_UpdatePullRequestStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRef provides a mock function for the type Client
func (_mock *Client) UpdateRef(context1 context.Context, updateRefArgs git.UpdateRefArgs) (*git.GitRef, error) {
	ret := _mock.Called(context1, updateRefArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRef")
	}

	var r0 *git.GitRef
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateRefArgs) (*git.GitRef, error)); ok {
		return returnFunc(context1, updateRefArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateRefArgs) *git.GitRef); ok {
		r0 = returnFunc(context1, updateRefArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRef)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdateRefArgs) error); ok {
		r1 = returnFunc(context1, updateRefArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdateRef_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRef'
type Client_UpdateRef_Call struct {
	*mock.Call
}

// UpdateRef is a helper method to define mock.On call
//   - context1 context.Context
//   - updateRefArgs git.UpdateRefArgs
func (_e *Client_Expecter) UpdateRef(context1 interface{}, updateRefArgs interface{}) *Client_UpdateRef_Call {
	return &Client_UpdateRef_Call{Call: _e.mock.On("UpdateRef", context1, updateRefArgs)}
}

func (_c *Client_UpdateRef_Call) Run(run func(context1 context.Context, updateRefArgs git.UpdateRefArgs)) *Client_UpdateRef_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdateRefArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdateRefArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdateRef_Call) Return(gitRef *git.GitRef, err error) *Client_UpdateRef_Call {
	_c.Call.Return(gitRef, err)
	return _c
}

func (_c *Client_UpdateRef_Call) RunAndReturn(run func(context1 context.Context, updateRefArgs git.UpdateRefArgs) (*git.GitRef, error)) *Client_UpdateRef_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRefs provides a mock function for the type Client
func (_mock *Client) UpdateRefs(context1 context.Context, updateRefsArgs git.UpdateRefsArgs) (*[]git.GitRefUpdateResult, error) {
	ret := _mock.Called(context1, updateRefsArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRefs")
	}

	var r0 *[]git.GitRefUpdateResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateRefsArgs) (*[]git.GitRefUpdateResult, error)); ok {
		return returnFunc(context1, updateRefsArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateRefsArgs) *[]git.GitRefUpdateResult); ok {
		r0 = returnFunc(context1, updateRefsArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*[]git.GitRefUpdateResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdateRefsArgs) error); ok {
		r1 = returnFunc(context1, updateRefsArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdateRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRefs'
type Client_UpdateRefs_Call struct {
	*mock.Call
}

// UpdateRefs is a helper method to define mock.On call
//   - context1 context.Context
//   - updateRefsArgs git.UpdateRefsArgs
func (_e *Client_Expecter) UpdateRefs(context1 interface{}, updateRefsArgs interface{}) *Client_UpdateRefs_Call {
	return &Client_UpdateRefs_Call{Call: _e.mock.On("UpdateRefs", context1, updateRefsArgs)}
}

func (_c *Client_UpdateRefs_Call) Run(run func(context1 context.Context, updateRefsArgs git.UpdateRefsArgs)) *Client_UpdateRefs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdateRefsArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdateRefsArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdateRefs_Call) Return(gitRefUpdateResults *[]git.GitRefUpdateResult, err error) *Client_UpdateRefs_Call {
	_c.Call.Return(gitRefUpdateResults, err)
	return _c
}

func (_c *Client_UpdateRefs_Call) RunAndReturn(run func(context1 context.Context, updateRefsArgs git.UpdateRefsArgs) (*[]git.GitRefUpdateResult, error)) *Client_UpdateRefs_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRepository provides a mock function for the type Client
func (_mock *Client) UpdateRepository(context1 context.Context, updateRepositoryArgs git.UpdateRepositoryArgs) (*git.GitRepository, error) {
	ret := _mock.Called(context1, updateRepositoryArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRepository")
	}

	var r0 *git.GitRepository
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateRepositoryArgs) (*git.GitRepository, error)); ok {
		return returnFunc(context1, updateRepositoryArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateRepositoryArgs) *git.GitRepository); ok {
		r0 = returnFunc(context1, updateRepositoryArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitRepository)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdateRepositoryArgs) error); ok {
		r1 = returnFunc(context1, updateRepositoryArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdateRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRepository'
type Client_UpdateRepository_Call struct {
	*mock.Call
}

// UpdateRepository is a helper method to define mock.On call
//   - context1 context.Context
//   - updateRepositoryArgs git.UpdateRepositoryArgs
func (_e *Client_Expecter) UpdateRepository(context1 interface{}, updateRepositoryArgs interface{}) *Client_UpdateRepository_Call {
	return &Client_UpdateRepository_Call{Call: _e.mock.On("UpdateRepository", context1, updateRepositoryArgs)}
}

func (_c *Client_UpdateRepository_Call) Run(run func(context1 context.Context, updateRepositoryArgs git.UpdateRepositoryArgs)) *Client_UpdateRepository_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdateRepositoryArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdateRepositoryArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdateRepository_Call) Return(gitRepository *git.GitRepository, err error) *Client_UpdateRepository_Call {
	_c.Call.Return(gitRepository, err)
	return _c
}

func (_c *Client_UpdateRepository_Call) RunAndReturn(run func(context1 context.Context, updateRepositoryArgs git.UpdateRepositoryArgs) (*git.GitRepository, error)) *Client_UpdateRepository_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateThread provides a mock function for the type Client
func (_mock *Client) UpdateThread(context1 context.Context, updateThreadArgs git.UpdateThreadArgs) (*git.GitPullRequestCommentThread, error) {
	ret := _mock.Called(context1, updateThreadArgs)

	if len(ret) == 0 {
		panic("no return value specified for UpdateThread")
	}

	var r0 *git.GitPullRequestCommentThread
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateThreadArgs) (*git.GitPullRequestCommentThread, error)); ok {
		return returnFunc(context1, updateThreadArgs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, git.UpdateThreadArgs) *git.GitPullRequestCommentThread); ok {
		r0 = returnFunc(context1, updateThreadArgs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*git.GitPullRequestCommentThread)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, git.UpdateThreadArgs) error); ok {
		r1 = returnFunc(context1, updateThreadArgs)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Client_UpdateThread_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateThread'
type Client_UpdateThread_Call struct {
	*mock.Call
}

// UpdateThread is a helper method to define mock.On call
//   - context1 context.Context
//   - updateThreadArgs git.UpdateThreadArgs
func (_e *Client_Expecter) UpdateThread(context1 interface{}, updateThreadArgs interface{}) *Client_UpdateThread_Call {
	return &Client_UpdateThread_Call{Call: _e.mock.On("UpdateThread", context1, updateThreadArgs)}
}

func (_c *Client_UpdateThread_Call) Run(run func(context1 context.Context, updateThreadArgs git.UpdateThreadArgs)) *Client_UpdateThread_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 git.UpdateThreadArgs
		if args[1] != nil {
			arg1 = args[1].(git.UpdateThreadArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Client_UpdateThread_Call) Return(gitPullRequestCommentThread *git.GitPullRequestCommentThread, err error) *Client_UpdateThread_Call {
	_c.Call.Return(gitPullRequestCommentThread, err)
	return _c
}

func (_c *Client_UpdateThread_Call) RunAndReturn(run func(context1 context.Context, updateThreadArgs git.UpdateThreadArgs) (*git.GitPullRequestCommentThread, error)) *Client_UpdateThread_Call {
	_c.Call.Return(run)
	return _c
}
