github.com/olli-ai/jx/v2@v2.0.400-0.20210921045218-14731b4dd448/pkg/gits/mocks/gitter.go

// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/olli-ai/jx/v2/pkg/gits (interfaces: Gitter)

package gits_test

import (
	io "io"
	"reflect"
	"time"

	auth "github.com/olli-ai/jx/v2/pkg/auth"
	gits "github.com/olli-ai/jx/v2/pkg/gits"
	pegomock "github.com/petergtz/pegomock"
	config "gopkg.in/src-d/go-git.v4/config"
)

type MockGitter struct {
	fail func(message string, callerSkip ...int)
}

func NewMockGitter(options ...pegomock.Option) *MockGitter {
	mock := &MockGitter{}
	for _, option := range options {
		option.Apply(mock)
	}
	return mock
}

func (mock *MockGitter) SetFailHandler(fh pegomock.FailHandler) { mock.fail = fh }
func (mock *MockGitter) FailHandler() pegomock.FailHandler      { return mock.fail }

func (mock *MockGitter) Add(_param0 string, _param1 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	for _, param := range _param1 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Add", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) AddCommit(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddCommit", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) AddCommitFiles(_param0 string, _param1 string, _param2 []string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddCommitFiles", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) AddRemote(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddRemote", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Branch(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Branch", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Checkout(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Checkout", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CheckoutCommitFiles(_param0 string, _param1 string, _param2 []string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CheckoutCommitFiles", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CheckoutOrphan(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CheckoutOrphan", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CheckoutRemoteBranch(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CheckoutRemoteBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CherryPick(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CherryPick", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CherryPickTheirs(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CherryPickTheirs", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CherryPickTheirsKeepRedundantCommits(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CherryPickTheirsKeepRedundantCommits", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CleanForce(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CleanForce", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Clone(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Clone", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CloneBare(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CloneBare", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CloneOrPull(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CloneOrPull", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CommitDir(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CommitDir", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CommitIfChanges(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CommitIfChanges", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Config(_param0 string, _param1 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	for _, param := range _param1 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Config", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) ConvertToValidBranchName(_param0 string) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ConvertToValidBranchName", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockGitter) CreateAuthenticatedURL(_param0 string, _param1 *auth.UserAuth) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateAuthenticatedURL", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) CreateBranch(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CreateBranchFrom(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateBranchFrom", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) CreateTag(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateTag", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) DeleteLocalBranch(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteLocalBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) DeleteRemoteBranch(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteRemoteBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Describe(_param0 string, _param1 bool, _param2 string, _param3 string, _param4 bool) (string, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Describe", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockGitter) Diff(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Diff", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) DiscoverRemoteGitURL(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DiscoverRemoteGitURL", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) DiscoverUpstreamGitURL(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DiscoverUpstreamGitURL", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Email(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Email", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) FetchBranch(_param0 string, _param1 string, _param2 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	for _, param := range _param2 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) FetchBranchShallow(_param0 string, _param1 string, _param2 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	for _, param := range _param2 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchBranchShallow", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) FetchBranchUnshallow(_param0 string, _param1 string, _param2 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	for _, param := range _param2 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchBranchUnshallow", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) FetchRemoteTags(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchRemoteTags", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) FetchTags(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchTags", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) FetchUnshallow(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchUnshallow", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) FilterTags(_param0 string, _param1 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FilterTags", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) FindGitConfigDir(_param0 string) (string, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FindGitConfigDir", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockGitter) ForcePushBranch(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ForcePushBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) GetAuthorEmailForCommit(_param0 string, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetAuthorEmailForCommit", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetCommitPointedToByLatestTag(_param0 string) (string, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetCommitPointedToByLatestTag", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockGitter) GetCommitPointedToByPreviousTag(_param0 string) (string, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetCommitPointedToByPreviousTag", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockGitter) GetCommitPointedToByTag(_param0 string, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetCommitPointedToByTag", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetCommits(_param0 string, _param1 string, _param2 string) ([]gits.GitCommit, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetCommits", params, []reflect.Type{reflect.TypeOf((*[]gits.GitCommit)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []gits.GitCommit
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]gits.GitCommit)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetCommitsNotOnAnyRemote(_param0 string, _param1 string) ([]gits.GitCommit, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetCommitsNotOnAnyRemote", params, []reflect.Type{reflect.TypeOf((*[]gits.GitCommit)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []gits.GitCommit
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]gits.GitCommit)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetFirstCommitSha(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetFirstCommitSha", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetLatestCommitMessage(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetLatestCommitMessage", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetLatestCommitSha(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetLatestCommitSha", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetRemoteUrl(_param0 *config.Config, _param1 string) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetRemoteUrl", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockGitter) GetRevisionBeforeDate(_param0 string, _param1 time.Time) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetRevisionBeforeDate", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) GetRevisionBeforeDateText(_param0 string, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetRevisionBeforeDateText", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) HasChanges(_param0 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("HasChanges", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) HasFileChanged(_param0 string, _param1 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("HasFileChanged", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Info(_param0 string) (*gits.GitRepository, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Info", params, []reflect.Type{reflect.TypeOf((**gits.GitRepository)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *gits.GitRepository
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*gits.GitRepository)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Init(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Init", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) IsAncestor(_param0 string, _param1 string, _param2 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsAncestor", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) IsFork(_param0 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsFork", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) IsShallow(_param0 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsShallow", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) IsVersionControlled(_param0 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsVersionControlled", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) ListChangedFilesFromBranch(_param0 string, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListChangedFilesFromBranch", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) LoadFileFromBranch(_param0 string, _param1 string, _param2 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("LoadFileFromBranch", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) LocalBranches(_param0 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("LocalBranches", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Merge(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Merge", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) MergeTheirs(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("MergeTheirs", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) PrintCreateRepositoryGenerateAccessToken(_param0 *auth.AuthServer, _param1 string, _param2 io.Writer) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	pegomock.GetGenericMockFrom(mock).Invoke("PrintCreateRepositoryGenerateAccessToken", params, []reflect.Type{})
}

func (mock *MockGitter) Pull(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Pull", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) PullRemoteBranches(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PullRemoteBranches", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) PullUpstream(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PullUpstream", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Push(_param0 string, _param1 string, _param2 bool, _param3 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	for _, param := range _param3 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Push", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) PushMaster(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PushMaster", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) PushMirror(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PushMirror", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) PushTag(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PushTag", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) ReadRepoAttributes(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ReadRepoAttributes", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) RebaseTheirs(_param0 string, _param1 string, _param2 string, _param3 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RebaseTheirs", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) RemoteBranchNames(_param0 string, _param1 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoteBranchNames", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) RemoteBranches(_param0 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoteBranches", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) RemoteMergedBranchNames(_param0 string, _param1 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoteMergedBranchNames", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) RemoteUpdate(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoteUpdate", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Remotes(_param0 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Remotes", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Remove(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Remove", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) RemoveForce(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveForce", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) RepoName(_param0 string, _param1 string) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RepoName", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockGitter) Reset(_param0 string, _param1 string, _param2 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Reset", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) ResetToUpstream(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ResetToUpstream", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) RevParse(_param0 string, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RevParse", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Server(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Server", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) SetEmail(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SetEmail", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) SetRemoteURL(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SetRemoteURL", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) SetUpstreamTo(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SetUpstreamTo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) SetUsername(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SetUsername", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) ShallowClone(_param0 string, _param1 string, _param2 string, _param3 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ShallowClone", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) ShallowCloneBranch(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ShallowCloneBranch", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) StashPop(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StashPop", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) StashPush(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StashPush", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Status(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Status", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Tags(_param0 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Tags", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) UpdateRemote(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateRemote", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) Username(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Username", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) Version() (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Version", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitter) WriteRepoAttributes(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("WriteRepoAttributes", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockGitter) VerifyWasCalledOnce() *VerifierMockGitter {
	return &VerifierMockGitter{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

func (mock *MockGitter) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockGitter {
	return &VerifierMockGitter{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
	}
}

func (mock *MockGitter) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierMockGitter {
	return &VerifierMockGitter{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		inOrderContext:         inOrderContext,
	}
}

func (mock *MockGitter) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockGitter {
	return &VerifierMockGitter{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		timeout:                timeout,
	}
}

type VerifierMockGitter struct {
	mock                   *MockGitter
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

func (verifier *VerifierMockGitter) Add(_param0 string, _param1 ...string) *MockGitter_Add_OngoingVerification {
	params := []pegomock.Param{_param0}
	for _, param := range _param1 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Add", params, verifier.timeout)
	return &MockGitter_Add_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Add_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Add_OngoingVerification) GetCapturedArguments() (string, []string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_Add_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([][]string, len(c.methodInvocations))
		for u := 0; u < len(c.methodInvocations); u++ {
			_param1[u] = make([]string, len(params)-1)
			for x := 1; x < len(params); x++ {
				if params[x][u] != nil {
					_param1[u][x-1] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockGitter) AddCommit(_param0 string, _param1 string) *MockGitter_AddCommit_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddCommit", params, verifier.timeout)
	return &MockGitter_AddCommit_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_AddCommit_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_AddCommit_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_AddCommit_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) AddCommitFiles(_param0 string, _param1 string, _param2 []string) *MockGitter_AddCommitFiles_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddCommitFiles", params, verifier.timeout)
	return &MockGitter_AddCommitFiles_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_AddCommitFiles_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_AddCommitFiles_OngoingVerification) GetCapturedArguments() (string, string, []string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_AddCommitFiles_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([][]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.([]string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) AddRemote(_param0 string, _param1 string, _param2 string) *MockGitter_AddRemote_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddRemote", params, verifier.timeout)
	return &MockGitter_AddRemote_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_AddRemote_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_AddRemote_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_AddRemote_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Branch(_param0 string) *MockGitter_Branch_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Branch", params, verifier.timeout)
	return &MockGitter_Branch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Branch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Branch_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Branch_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Checkout(_param0 string, _param1 string) *MockGitter_Checkout_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Checkout", params, verifier.timeout)
	return &MockGitter_Checkout_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Checkout_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Checkout_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_Checkout_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CheckoutCommitFiles(_param0 string, _param1 string, _param2 []string) *MockGitter_CheckoutCommitFiles_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CheckoutCommitFiles", params, verifier.timeout)
	return &MockGitter_CheckoutCommitFiles_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CheckoutCommitFiles_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CheckoutCommitFiles_OngoingVerification) GetCapturedArguments() (string, string, []string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_CheckoutCommitFiles_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([][]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.([]string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CheckoutOrphan(_param0 string, _param1 string) *MockGitter_CheckoutOrphan_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CheckoutOrphan", params, verifier.timeout)
	return &MockGitter_CheckoutOrphan_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CheckoutOrphan_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CheckoutOrphan_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CheckoutOrphan_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CheckoutRemoteBranch(_param0 string, _param1 string) *MockGitter_CheckoutRemoteBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CheckoutRemoteBranch", params, verifier.timeout)
	return &MockGitter_CheckoutRemoteBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CheckoutRemoteBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CheckoutRemoteBranch_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CheckoutRemoteBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CherryPick(_param0 string, _param1 string) *MockGitter_CherryPick_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CherryPick", params, verifier.timeout)
	return &MockGitter_CherryPick_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CherryPick_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CherryPick_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CherryPick_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CherryPickTheirs(_param0 string, _param1 string) *MockGitter_CherryPickTheirs_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CherryPickTheirs", params, verifier.timeout)
	return &MockGitter_CherryPickTheirs_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CherryPickTheirs_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CherryPickTheirs_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CherryPickTheirs_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CherryPickTheirsKeepRedundantCommits(_param0 string, _param1 string) *MockGitter_CherryPickTheirsKeepRedundantCommits_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CherryPickTheirsKeepRedundantCommits", params, verifier.timeout)
	return &MockGitter_CherryPickTheirsKeepRedundantCommits_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CherryPickTheirsKeepRedundantCommits_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CherryPickTheirsKeepRedundantCommits_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CherryPickTheirsKeepRedundantCommits_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CleanForce(_param0 string, _param1 string) *MockGitter_CleanForce_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CleanForce", params, verifier.timeout)
	return &MockGitter_CleanForce_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CleanForce_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CleanForce_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CleanForce_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Clone(_param0 string, _param1 string) *MockGitter_Clone_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Clone", params, verifier.timeout)
	return &MockGitter_Clone_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Clone_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Clone_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_Clone_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CloneBare(_param0 string, _param1 string) *MockGitter_CloneBare_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CloneBare", params, verifier.timeout)
	return &MockGitter_CloneBare_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CloneBare_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CloneBare_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CloneBare_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CloneOrPull(_param0 string, _param1 string) *MockGitter_CloneOrPull_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CloneOrPull", params, verifier.timeout)
	return &MockGitter_CloneOrPull_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CloneOrPull_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CloneOrPull_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CloneOrPull_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CommitDir(_param0 string, _param1 string) *MockGitter_CommitDir_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CommitDir", params, verifier.timeout)
	return &MockGitter_CommitDir_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CommitDir_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CommitDir_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CommitDir_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CommitIfChanges(_param0 string, _param1 string) *MockGitter_CommitIfChanges_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CommitIfChanges", params, verifier.timeout)
	return &MockGitter_CommitIfChanges_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CommitIfChanges_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CommitIfChanges_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CommitIfChanges_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Config(_param0 string, _param1 ...string) *MockGitter_Config_OngoingVerification {
	params := []pegomock.Param{_param0}
	for _, param := range _param1 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Config", params, verifier.timeout)
	return &MockGitter_Config_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Config_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Config_OngoingVerification) GetCapturedArguments() (string, []string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_Config_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([][]string, len(c.methodInvocations))
		for u := 0; u < len(c.methodInvocations); u++ {
			_param1[u] = make([]string, len(params)-1)
			for x := 1; x < len(params); x++ {
				if params[x][u] != nil {
					_param1[u][x-1] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockGitter) ConvertToValidBranchName(_param0 string) *MockGitter_ConvertToValidBranchName_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ConvertToValidBranchName", params, verifier.timeout)
	return &MockGitter_ConvertToValidBranchName_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ConvertToValidBranchName_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ConvertToValidBranchName_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_ConvertToValidBranchName_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CreateAuthenticatedURL(_param0 string, _param1 *auth.UserAuth) *MockGitter_CreateAuthenticatedURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateAuthenticatedURL", params, verifier.timeout)
	return &MockGitter_CreateAuthenticatedURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CreateAuthenticatedURL_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CreateAuthenticatedURL_OngoingVerification) GetCapturedArguments() (string, *auth.UserAuth) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CreateAuthenticatedURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []*auth.UserAuth) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]*auth.UserAuth, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(*auth.UserAuth)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CreateBranch(_param0 string, _param1 string) *MockGitter_CreateBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateBranch", params, verifier.timeout)
	return &MockGitter_CreateBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CreateBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CreateBranch_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_CreateBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CreateBranchFrom(_param0 string, _param1 string, _param2 string) *MockGitter_CreateBranchFrom_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateBranchFrom", params, verifier.timeout)
	return &MockGitter_CreateBranchFrom_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CreateBranchFrom_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CreateBranchFrom_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_CreateBranchFrom_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) CreateTag(_param0 string, _param1 string, _param2 string) *MockGitter_CreateTag_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateTag", params, verifier.timeout)
	return &MockGitter_CreateTag_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_CreateTag_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_CreateTag_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_CreateTag_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) DeleteLocalBranch(_param0 string, _param1 string) *MockGitter_DeleteLocalBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteLocalBranch", params, verifier.timeout)
	return &MockGitter_DeleteLocalBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_DeleteLocalBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_DeleteLocalBranch_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_DeleteLocalBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) DeleteRemoteBranch(_param0 string, _param1 string, _param2 string) *MockGitter_DeleteRemoteBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteRemoteBranch", params, verifier.timeout)
	return &MockGitter_DeleteRemoteBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_DeleteRemoteBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_DeleteRemoteBranch_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_DeleteRemoteBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Describe(_param0 string, _param1 bool, _param2 string, _param3 string, _param4 bool) *MockGitter_Describe_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Describe", params, verifier.timeout)
	return &MockGitter_Describe_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Describe_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Describe_OngoingVerification) GetCapturedArguments() (string, bool, string, string, bool) {
	_param0, _param1, _param2, _param3, _param4 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1]
}

func (c *MockGitter_Describe_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []bool, _param2 []string, _param3 []string, _param4 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]bool, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(bool)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]string, len(c.methodInvocations))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
		_param4 = make([]bool, len(c.methodInvocations))
		for u, param := range params[4] {
			_param4[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Diff(_param0 string) *MockGitter_Diff_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Diff", params, verifier.timeout)
	return &MockGitter_Diff_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Diff_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Diff_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Diff_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) DiscoverRemoteGitURL(_param0 string) *MockGitter_DiscoverRemoteGitURL_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DiscoverRemoteGitURL", params, verifier.timeout)
	return &MockGitter_DiscoverRemoteGitURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_DiscoverRemoteGitURL_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_DiscoverRemoteGitURL_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_DiscoverRemoteGitURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) DiscoverUpstreamGitURL(_param0 string) *MockGitter_DiscoverUpstreamGitURL_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DiscoverUpstreamGitURL", params, verifier.timeout)
	return &MockGitter_DiscoverUpstreamGitURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_DiscoverUpstreamGitURL_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_DiscoverUpstreamGitURL_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_DiscoverUpstreamGitURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Email(_param0 string) *MockGitter_Email_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Email", params, verifier.timeout)
	return &MockGitter_Email_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Email_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Email_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Email_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) FetchBranch(_param0 string, _param1 string, _param2 ...string) *MockGitter_FetchBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	for _, param := range _param2 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchBranch", params, verifier.timeout)
	return &MockGitter_FetchBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FetchBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FetchBranch_OngoingVerification) GetCapturedArguments() (string, string, []string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_FetchBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([][]string, len(c.methodInvocations))
		for u := 0; u < len(c.methodInvocations); u++ {
			_param2[u] = make([]string, len(params)-2)
			for x := 2; x < len(params); x++ {
				if params[x][u] != nil {
					_param2[u][x-2] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockGitter) FetchBranchShallow(_param0 string, _param1 string, _param2 ...string) *MockGitter_FetchBranchShallow_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	for _, param := range _param2 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchBranchShallow", params, verifier.timeout)
	return &MockGitter_FetchBranchShallow_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FetchBranchShallow_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FetchBranchShallow_OngoingVerification) GetCapturedArguments() (string, string, []string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_FetchBranchShallow_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([][]string, len(c.methodInvocations))
		for u := 0; u < len(c.methodInvocations); u++ {
			_param2[u] = make([]string, len(params)-2)
			for x := 2; x < len(params); x++ {
				if params[x][u] != nil {
					_param2[u][x-2] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockGitter) FetchBranchUnshallow(_param0 string, _param1 string, _param2 ...string) *MockGitter_FetchBranchUnshallow_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	for _, param := range _param2 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchBranchUnshallow", params, verifier.timeout)
	return &MockGitter_FetchBranchUnshallow_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FetchBranchUnshallow_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FetchBranchUnshallow_OngoingVerification) GetCapturedArguments() (string, string, []string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_FetchBranchUnshallow_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([][]string, len(c.methodInvocations))
		for u := 0; u < len(c.methodInvocations); u++ {
			_param2[u] = make([]string, len(params)-2)
			for x := 2; x < len(params); x++ {
				if params[x][u] != nil {
					_param2[u][x-2] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockGitter) FetchRemoteTags(_param0 string, _param1 string) *MockGitter_FetchRemoteTags_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchRemoteTags", params, verifier.timeout)
	return &MockGitter_FetchRemoteTags_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FetchRemoteTags_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FetchRemoteTags_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_FetchRemoteTags_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) FetchTags(_param0 string) *MockGitter_FetchTags_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchTags", params, verifier.timeout)
	return &MockGitter_FetchTags_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FetchTags_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FetchTags_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_FetchTags_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) FetchUnshallow(_param0 string) *MockGitter_FetchUnshallow_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchUnshallow", params, verifier.timeout)
	return &MockGitter_FetchUnshallow_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FetchUnshallow_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FetchUnshallow_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_FetchUnshallow_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) FilterTags(_param0 string, _param1 string) *MockGitter_FilterTags_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FilterTags", params, verifier.timeout)
	return &MockGitter_FilterTags_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FilterTags_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FilterTags_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_FilterTags_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) FindGitConfigDir(_param0 string) *MockGitter_FindGitConfigDir_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FindGitConfigDir", params, verifier.timeout)
	return &MockGitter_FindGitConfigDir_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_FindGitConfigDir_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_FindGitConfigDir_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_FindGitConfigDir_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) ForcePushBranch(_param0 string, _param1 string, _param2 string) *MockGitter_ForcePushBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ForcePushBranch", params, verifier.timeout)
	return &MockGitter_ForcePushBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ForcePushBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ForcePushBranch_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_ForcePushBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetAuthorEmailForCommit(_param0 string, _param1 string) *MockGitter_GetAuthorEmailForCommit_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetAuthorEmailForCommit", params, verifier.timeout)
	return &MockGitter_GetAuthorEmailForCommit_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetAuthorEmailForCommit_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetAuthorEmailForCommit_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_GetAuthorEmailForCommit_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetCommitPointedToByLatestTag(_param0 string) *MockGitter_GetCommitPointedToByLatestTag_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCommitPointedToByLatestTag", params, verifier.timeout)
	return &MockGitter_GetCommitPointedToByLatestTag_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetCommitPointedToByLatestTag_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetCommitPointedToByLatestTag_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_GetCommitPointedToByLatestTag_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetCommitPointedToByPreviousTag(_param0 string) *MockGitter_GetCommitPointedToByPreviousTag_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCommitPointedToByPreviousTag", params, verifier.timeout)
	return &MockGitter_GetCommitPointedToByPreviousTag_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetCommitPointedToByPreviousTag_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetCommitPointedToByPreviousTag_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_GetCommitPointedToByPreviousTag_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetCommitPointedToByTag(_param0 string, _param1 string) *MockGitter_GetCommitPointedToByTag_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCommitPointedToByTag", params, verifier.timeout)
	return &MockGitter_GetCommitPointedToByTag_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetCommitPointedToByTag_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetCommitPointedToByTag_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_GetCommitPointedToByTag_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetCommits(_param0 string, _param1 string, _param2 string) *MockGitter_GetCommits_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCommits", params, verifier.timeout)
	return &MockGitter_GetCommits_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetCommits_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetCommits_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_GetCommits_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetCommitsNotOnAnyRemote(_param0 string, _param1 string) *MockGitter_GetCommitsNotOnAnyRemote_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCommitsNotOnAnyRemote", params, verifier.timeout)
	return &MockGitter_GetCommitsNotOnAnyRemote_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetCommitsNotOnAnyRemote_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetCommitsNotOnAnyRemote_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_GetCommitsNotOnAnyRemote_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetFirstCommitSha(_param0 string) *MockGitter_GetFirstCommitSha_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetFirstCommitSha", params, verifier.timeout)
	return &MockGitter_GetFirstCommitSha_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetFirstCommitSha_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetFirstCommitSha_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_GetFirstCommitSha_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetLatestCommitMessage(_param0 string) *MockGitter_GetLatestCommitMessage_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetLatestCommitMessage", params, verifier.timeout)
	return &MockGitter_GetLatestCommitMessage_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetLatestCommitMessage_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetLatestCommitMessage_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_GetLatestCommitMessage_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetLatestCommitSha(_param0 string) *MockGitter_GetLatestCommitSha_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetLatestCommitSha", params, verifier.timeout)
	return &MockGitter_GetLatestCommitSha_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetLatestCommitSha_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetLatestCommitSha_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_GetLatestCommitSha_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetRemoteUrl(_param0 *config.Config, _param1 string) *MockGitter_GetRemoteUrl_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetRemoteUrl", params, verifier.timeout)
	return &MockGitter_GetRemoteUrl_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetRemoteUrl_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetRemoteUrl_OngoingVerification) GetCapturedArguments() (*config.Config, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_GetRemoteUrl_OngoingVerification) GetAllCapturedArguments() (_param0 []*config.Config, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]*config.Config, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(*config.Config)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetRevisionBeforeDate(_param0 string, _param1 time.Time) *MockGitter_GetRevisionBeforeDate_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetRevisionBeforeDate", params, verifier.timeout)
	return &MockGitter_GetRevisionBeforeDate_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetRevisionBeforeDate_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetRevisionBeforeDate_OngoingVerification) GetCapturedArguments() (string, time.Time) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_GetRevisionBeforeDate_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []time.Time) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]time.Time, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(time.Time)
		}
	}
	return
}

func (verifier *VerifierMockGitter) GetRevisionBeforeDateText(_param0 string, _param1 string) *MockGitter_GetRevisionBeforeDateText_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetRevisionBeforeDateText", params, verifier.timeout)
	return &MockGitter_GetRevisionBeforeDateText_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_GetRevisionBeforeDateText_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_GetRevisionBeforeDateText_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_GetRevisionBeforeDateText_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) HasChanges(_param0 string) *MockGitter_HasChanges_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HasChanges", params, verifier.timeout)
	return &MockGitter_HasChanges_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_HasChanges_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_HasChanges_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_HasChanges_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) HasFileChanged(_param0 string, _param1 string) *MockGitter_HasFileChanged_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HasFileChanged", params, verifier.timeout)
	return &MockGitter_HasFileChanged_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_HasFileChanged_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_HasFileChanged_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_HasFileChanged_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Info(_param0 string) *MockGitter_Info_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Info", params, verifier.timeout)
	return &MockGitter_Info_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Info_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Info_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Info_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Init(_param0 string) *MockGitter_Init_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Init", params, verifier.timeout)
	return &MockGitter_Init_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Init_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Init_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Init_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) IsAncestor(_param0 string, _param1 string, _param2 string) *MockGitter_IsAncestor_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsAncestor", params, verifier.timeout)
	return &MockGitter_IsAncestor_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_IsAncestor_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_IsAncestor_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_IsAncestor_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) IsFork(_param0 string) *MockGitter_IsFork_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsFork", params, verifier.timeout)
	return &MockGitter_IsFork_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_IsFork_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_IsFork_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_IsFork_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) IsShallow(_param0 string) *MockGitter_IsShallow_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsShallow", params, verifier.timeout)
	return &MockGitter_IsShallow_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_IsShallow_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_IsShallow_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_IsShallow_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) IsVersionControlled(_param0 string) *MockGitter_IsVersionControlled_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsVersionControlled", params, verifier.timeout)
	return &MockGitter_IsVersionControlled_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_IsVersionControlled_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_IsVersionControlled_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_IsVersionControlled_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) ListChangedFilesFromBranch(_param0 string, _param1 string) *MockGitter_ListChangedFilesFromBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListChangedFilesFromBranch", params, verifier.timeout)
	return &MockGitter_ListChangedFilesFromBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ListChangedFilesFromBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ListChangedFilesFromBranch_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_ListChangedFilesFromBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) LoadFileFromBranch(_param0 string, _param1 string, _param2 string) *MockGitter_LoadFileFromBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "LoadFileFromBranch", params, verifier.timeout)
	return &MockGitter_LoadFileFromBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_LoadFileFromBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_LoadFileFromBranch_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_LoadFileFromBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) LocalBranches(_param0 string) *MockGitter_LocalBranches_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "LocalBranches", params, verifier.timeout)
	return &MockGitter_LocalBranches_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_LocalBranches_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_LocalBranches_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_LocalBranches_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Merge(_param0 string, _param1 string) *MockGitter_Merge_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Merge", params, verifier.timeout)
	return &MockGitter_Merge_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Merge_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Merge_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_Merge_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) MergeTheirs(_param0 string, _param1 string) *MockGitter_MergeTheirs_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "MergeTheirs", params, verifier.timeout)
	return &MockGitter_MergeTheirs_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_MergeTheirs_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_MergeTheirs_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_MergeTheirs_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) PrintCreateRepositoryGenerateAccessToken(_param0 *auth.AuthServer, _param1 string, _param2 io.Writer) *MockGitter_PrintCreateRepositoryGenerateAccessToken_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PrintCreateRepositoryGenerateAccessToken", params, verifier.timeout)
	return &MockGitter_PrintCreateRepositoryGenerateAccessToken_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_PrintCreateRepositoryGenerateAccessToken_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_PrintCreateRepositoryGenerateAccessToken_OngoingVerification) GetCapturedArguments() (*auth.AuthServer, string, io.Writer) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_PrintCreateRepositoryGenerateAccessToken_OngoingVerification) GetAllCapturedArguments() (_param0 []*auth.AuthServer, _param1 []string, _param2 []io.Writer) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]*auth.AuthServer, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(*auth.AuthServer)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]io.Writer, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(io.Writer)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Pull(_param0 string) *MockGitter_Pull_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Pull", params, verifier.timeout)
	return &MockGitter_Pull_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Pull_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Pull_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Pull_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) PullRemoteBranches(_param0 string) *MockGitter_PullRemoteBranches_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullRemoteBranches", params, verifier.timeout)
	return &MockGitter_PullRemoteBranches_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_PullRemoteBranches_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_PullRemoteBranches_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_PullRemoteBranches_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) PullUpstream(_param0 string) *MockGitter_PullUpstream_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullUpstream", params, verifier.timeout)
	return &MockGitter_PullUpstream_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_PullUpstream_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_PullUpstream_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_PullUpstream_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Push(_param0 string, _param1 string, _param2 bool, _param3 ...string) *MockGitter_Push_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	for _, param := range _param3 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Push", params, verifier.timeout)
	return &MockGitter_Push_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Push_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Push_OngoingVerification) GetCapturedArguments() (string, string, bool, []string) {
	_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}

func (c *MockGitter_Push_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool, _param3 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]bool, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(bool)
		}
		_param3 = make([][]string, len(c.methodInvocations))
		for u := 0; u < len(c.methodInvocations); u++ {
			_param3[u] = make([]string, len(params)-3)
			for x := 3; x < len(params); x++ {
				if params[x][u] != nil {
					_param3[u][x-3] = params[x][u].(string)
				}
			}
		}
	}
	return
}

func (verifier *VerifierMockGitter) PushMaster(_param0 string) *MockGitter_PushMaster_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PushMaster", params, verifier.timeout)
	return &MockGitter_PushMaster_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_PushMaster_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_PushMaster_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_PushMaster_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) PushMirror(_param0 string, _param1 string) *MockGitter_PushMirror_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PushMirror", params, verifier.timeout)
	return &MockGitter_PushMirror_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_PushMirror_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_PushMirror_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_PushMirror_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) PushTag(_param0 string, _param1 string) *MockGitter_PushTag_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PushTag", params, verifier.timeout)
	return &MockGitter_PushTag_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_PushTag_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_PushTag_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_PushTag_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) ReadRepoAttributes(_param0 string) *MockGitter_ReadRepoAttributes_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ReadRepoAttributes", params, verifier.timeout)
	return &MockGitter_ReadRepoAttributes_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ReadRepoAttributes_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ReadRepoAttributes_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_ReadRepoAttributes_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RebaseTheirs(_param0 string, _param1 string, _param2 string, _param3 bool) *MockGitter_RebaseTheirs_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RebaseTheirs", params, verifier.timeout)
	return &MockGitter_RebaseTheirs_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RebaseTheirs_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RebaseTheirs_OngoingVerification) GetCapturedArguments() (string, string, string, bool) {
	_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}

func (c *MockGitter_RebaseTheirs_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]bool, len(c.methodInvocations))
		for u, param := range params[3] {
			_param3[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RemoteBranchNames(_param0 string, _param1 string) *MockGitter_RemoteBranchNames_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoteBranchNames", params, verifier.timeout)
	return &MockGitter_RemoteBranchNames_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RemoteBranchNames_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RemoteBranchNames_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_RemoteBranchNames_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RemoteBranches(_param0 string) *MockGitter_RemoteBranches_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoteBranches", params, verifier.timeout)
	return &MockGitter_RemoteBranches_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RemoteBranches_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RemoteBranches_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_RemoteBranches_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RemoteMergedBranchNames(_param0 string, _param1 string) *MockGitter_RemoteMergedBranchNames_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoteMergedBranchNames", params, verifier.timeout)
	return &MockGitter_RemoteMergedBranchNames_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RemoteMergedBranchNames_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RemoteMergedBranchNames_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_RemoteMergedBranchNames_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RemoteUpdate(_param0 string) *MockGitter_RemoteUpdate_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoteUpdate", params, verifier.timeout)
	return &MockGitter_RemoteUpdate_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RemoteUpdate_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RemoteUpdate_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_RemoteUpdate_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Remotes(_param0 string) *MockGitter_Remotes_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Remotes", params, verifier.timeout)
	return &MockGitter_Remotes_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Remotes_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Remotes_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Remotes_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Remove(_param0 string, _param1 string) *MockGitter_Remove_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Remove", params, verifier.timeout)
	return &MockGitter_Remove_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Remove_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Remove_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_Remove_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RemoveForce(_param0 string, _param1 string) *MockGitter_RemoveForce_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveForce", params, verifier.timeout)
	return &MockGitter_RemoveForce_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RemoveForce_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RemoveForce_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_RemoveForce_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RepoName(_param0 string, _param1 string) *MockGitter_RepoName_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RepoName", params, verifier.timeout)
	return &MockGitter_RepoName_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RepoName_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RepoName_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_RepoName_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Reset(_param0 string, _param1 string, _param2 bool) *MockGitter_Reset_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Reset", params, verifier.timeout)
	return &MockGitter_Reset_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Reset_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Reset_OngoingVerification) GetCapturedArguments() (string, string, bool) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_Reset_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]bool, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierMockGitter) ResetToUpstream(_param0 string, _param1 string) *MockGitter_ResetToUpstream_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ResetToUpstream", params, verifier.timeout)
	return &MockGitter_ResetToUpstream_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ResetToUpstream_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ResetToUpstream_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_ResetToUpstream_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) RevParse(_param0 string, _param1 string) *MockGitter_RevParse_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RevParse", params, verifier.timeout)
	return &MockGitter_RevParse_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_RevParse_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_RevParse_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_RevParse_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Server(_param0 string) *MockGitter_Server_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Server", params, verifier.timeout)
	return &MockGitter_Server_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Server_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Server_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Server_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) SetEmail(_param0 string, _param1 string) *MockGitter_SetEmail_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetEmail", params, verifier.timeout)
	return &MockGitter_SetEmail_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_SetEmail_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_SetEmail_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_SetEmail_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) SetRemoteURL(_param0 string, _param1 string, _param2 string) *MockGitter_SetRemoteURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetRemoteURL", params, verifier.timeout)
	return &MockGitter_SetRemoteURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_SetRemoteURL_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_SetRemoteURL_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_SetRemoteURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) SetUpstreamTo(_param0 string, _param1 string) *MockGitter_SetUpstreamTo_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetUpstreamTo", params, verifier.timeout)
	return &MockGitter_SetUpstreamTo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_SetUpstreamTo_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_SetUpstreamTo_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_SetUpstreamTo_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) SetUsername(_param0 string, _param1 string) *MockGitter_SetUsername_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetUsername", params, verifier.timeout)
	return &MockGitter_SetUsername_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_SetUsername_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_SetUsername_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_SetUsername_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) ShallowClone(_param0 string, _param1 string, _param2 string, _param3 string) *MockGitter_ShallowClone_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ShallowClone", params, verifier.timeout)
	return &MockGitter_ShallowClone_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ShallowClone_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ShallowClone_OngoingVerification) GetCapturedArguments() (string, string, string, string) {
	_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}

func (c *MockGitter_ShallowClone_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]string, len(c.methodInvocations))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) ShallowCloneBranch(_param0 string, _param1 string, _param2 string) *MockGitter_ShallowCloneBranch_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ShallowCloneBranch", params, verifier.timeout)
	return &MockGitter_ShallowCloneBranch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_ShallowCloneBranch_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_ShallowCloneBranch_OngoingVerification) GetCapturedArguments() (string, string, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *MockGitter_ShallowCloneBranch_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) StashPop(_param0 string) *MockGitter_StashPop_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StashPop", params, verifier.timeout)
	return &MockGitter_StashPop_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_StashPop_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_StashPop_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_StashPop_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) StashPush(_param0 string) *MockGitter_StashPush_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StashPush", params, verifier.timeout)
	return &MockGitter_StashPush_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_StashPush_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_StashPush_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_StashPush_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Status(_param0 string) *MockGitter_Status_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Status", params, verifier.timeout)
	return &MockGitter_Status_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Status_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Status_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Status_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Tags(_param0 string) *MockGitter_Tags_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Tags", params, verifier.timeout)
	return &MockGitter_Tags_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Tags_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Tags_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Tags_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) UpdateRemote(_param0 string, _param1 string) *MockGitter_UpdateRemote_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateRemote", params, verifier.timeout)
	return &MockGitter_UpdateRemote_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_UpdateRemote_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_UpdateRemote_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_UpdateRemote_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Username(_param0 string) *MockGitter_Username_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Username", params, verifier.timeout)
	return &MockGitter_Username_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Username_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Username_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *MockGitter_Username_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierMockGitter) Version() *MockGitter_Version_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Version", params, verifier.timeout)
	return &MockGitter_Version_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_Version_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_Version_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitter_Version_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockGitter) WriteRepoAttributes(_param0 string, _param1 string) *MockGitter_WriteRepoAttributes_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "WriteRepoAttributes", params, verifier.timeout)
	return &MockGitter_WriteRepoAttributes_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitter_WriteRepoAttributes_OngoingVerification struct {
	mock              *MockGitter
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitter_WriteRepoAttributes_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *MockGitter_WriteRepoAttributes_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}