gitter.go

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

package gits_test

import (
	auth "github.com/jenkins-x/jx/pkg/auth"
	gits "github.com/jenkins-x/jx/pkg/gits"
	pegomock "github.com/petergtz/pegomock"
	config "gopkg.in/src-d/go-git.v4/config"
	io "io"
	"reflect"
	time "time"
)

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

func NewMockGitter() *MockGitter {
	return &MockGitter{fail: pegomock.GlobalFailHandler}
}

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) AddCommmit(_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("AddCommmit", 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) 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) 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) 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) 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) 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) CreatePushURL(_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("CreatePushURL", 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) 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) 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) 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, _param2}
	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) 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) 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) GetCurrentGitTagSHA(_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("GetCurrentGitTagSHA", 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) GetPreviousGitTagSHA(_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("GetPreviousGitTagSHA", 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) Info(_param0 string) (*gits.GitRepositoryInfo, 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.GitRepositoryInfo)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *gits.GitRepositoryInfo
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*gits.GitRepositoryInfo)
		}
		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) IsFork(_param0 gits.GitProvider, _param1 *gits.GitRepositoryInfo, _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("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) 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) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	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) 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) 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) 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) 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) 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) Stash(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Stash", 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) ToGitLabels(_param0 []string) []gits.GitLabel {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitter().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ToGitLabels", params, []reflect.Type{reflect.TypeOf((*[]gits.GitLabel)(nil)).Elem()})
	var ret0 []gits.GitLabel
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]gits.GitLabel)
		}
	}
	return ret0
}

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) VerifyWasCalledOnce() *VerifierGitter {
	return &VerifierGitter{mock, pegomock.Times(1), nil}
}

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

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

type VerifierGitter struct {
	mock                   *MockGitter
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
}

func (verifier *VerifierGitter) Add(_param0 string, _param1 ...string) *Gitter_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)
	return &Gitter_Add_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

func (c *Gitter_Add_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([][]string, len(params[1]))
		for u := range params[0] {
			_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 *VerifierGitter) AddCommmit(_param0 string, _param1 string) *Gitter_AddCommmit_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddCommmit", params)
	return &Gitter_AddCommmit_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

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

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

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

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

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

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

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

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

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

func (verifier *VerifierGitter) GetCurrentGitTagSHA(_param0 string) *Gitter_GetCurrentGitTagSHA_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCurrentGitTagSHA", params)
	return &Gitter_GetCurrentGitTagSHA_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

func (verifier *VerifierGitter) GetPreviousGitTagSHA(_param0 string) *Gitter_GetPreviousGitTagSHA_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetPreviousGitTagSHA", params)
	return &Gitter_GetPreviousGitTagSHA_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

func (c *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(*config.Config)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (verifier *VerifierGitter) IsFork(_param0 gits.GitProvider, _param1 *gits.GitRepositoryInfo, _param2 string) *Gitter_IsFork_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsFork", params)
	return &Gitter_IsFork_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(*auth.AuthServer)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]io.Writer, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(io.Writer)
		}
	}
	return
}

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

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

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

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

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

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

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

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

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

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

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

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

func (verifier *VerifierGitter) Push(_param0 string) *Gitter_Push_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Push", params)
	return &Gitter_Push_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *Gitter_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 *Gitter_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

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

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

func (verifier *VerifierGitter) Stash(_param0 string) *Gitter_Stash_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Stash", params)
	return &Gitter_Stash_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

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

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

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

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

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

func (verifier *VerifierGitter) ToGitLabels(_param0 []string) *Gitter_ToGitLabels_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ToGitLabels", params)
	return &Gitter_ToGitLabels_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *Gitter_Version_OngoingVerification) GetCapturedArguments() {
}

func (c *Gitter_Version_OngoingVerification) GetAllCapturedArguments() {
}