git_provider.go

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

package gits_test

import (
	github "github.com/google/go-github/github"
	auth "github.com/jenkins-x/jx/pkg/auth"
	gits "github.com/jenkins-x/jx/pkg/gits"
	pegomock "github.com/petergtz/pegomock"
	"reflect"
	"time"
)

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

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

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

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

func (mock *MockGitProvider) AddCollaborator(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddCollaborator", 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 *MockGitProvider) AddPRComment(_param0 *gits.GitPullRequest, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddPRComment", 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 *MockGitProvider) BranchArchiveURL(_param0 string, _param1 string, _param2 string) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("BranchArchiveURL", 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 *MockGitProvider) CreateIssue(_param0 string, _param1 string, _param2 *gits.GitIssue) (*gits.GitIssue, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateIssue", params, []reflect.Type{reflect.TypeOf((**gits.GitIssue)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *gits.GitIssue
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*gits.GitIssue)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGitProvider) CreateIssueComment(_param0 string, _param1 string, _param2 int, _param3 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateIssueComment", 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 *MockGitProvider) CreatePullRequest(_param0 *gits.GitPullRequestArguments) (*gits.GitPullRequest, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreatePullRequest", params, []reflect.Type{reflect.TypeOf((**gits.GitPullRequest)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *gits.GitPullRequest
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*gits.GitPullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

func (mock *MockGitProvider) CreateWebHook(_param0 *gits.GitWebHookArguments) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateWebHook", 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 *MockGitProvider) CurrentUsername() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CurrentUsername", 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 *MockGitProvider) DeleteRepository(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteRepository", 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 *MockGitProvider) ForkRepository(_param0 string, _param1 string, _param2 string) (*gits.GitRepository, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ForkRepository", params, []reflect.Type{reflect.TypeOf((**gits.GitRepository)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *gits.GitRepository
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*gits.GitRepository)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

func (mock *MockGitProvider) IssueURL(_param0 string, _param1 string, _param2 int, _param3 bool) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IssueURL", 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 *MockGitProvider) JenkinsWebHookPath(_param0 string, _param1 string) string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("JenkinsWebHookPath", 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 *MockGitProvider) Kind() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Kind", 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 *MockGitProvider) Label() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Label", 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 *MockGitProvider) ListCommitStatus(_param0 string, _param1 string, _param2 string) ([]*gits.GitRepoStatus, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListCommitStatus", params, []reflect.Type{reflect.TypeOf((*[]*gits.GitRepoStatus)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []*gits.GitRepoStatus
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]*gits.GitRepoStatus)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

func (mock *MockGitProvider) ListInvitations() ([]*github.RepositoryInvitation, *github.Response, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListInvitations", params, []reflect.Type{reflect.TypeOf((*[]*github.RepositoryInvitation)(nil)).Elem(), reflect.TypeOf((**github.Response)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []*github.RepositoryInvitation
	var ret1 *github.Response
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]*github.RepositoryInvitation)
		}
		if result[1] != nil {
			ret1 = result[1].(*github.Response)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

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

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

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

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

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

func (mock *MockGitProvider) MergePullRequest(_param0 *gits.GitPullRequest, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("MergePullRequest", 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 *MockGitProvider) PullRequestLastCommitStatus(_param0 *gits.GitPullRequest) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PullRequestLastCommitStatus", 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 *MockGitProvider) RenameRepository(_param0 string, _param1 string, _param2 string) (*gits.GitRepository, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RenameRepository", params, []reflect.Type{reflect.TypeOf((**gits.GitRepository)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *gits.GitRepository
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*gits.GitRepository)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

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

func (mock *MockGitProvider) ServerURL() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ServerURL", 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 *MockGitProvider) ShouldForkForPullRequest(_param0 string, _param1 string, _param2 string) bool {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ShouldForkForPullRequest", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem()})
	var ret0 bool
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
	}
	return ret0
}

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

func (mock *MockGitProvider) UpdatePullRequestStatus(_param0 *gits.GitPullRequest) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdatePullRequestStatus", 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 *MockGitProvider) UpdateRelease(_param0 string, _param1 string, _param2 string, _param3 *gits.GitRelease) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateRelease", 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 *MockGitProvider) UpdateWebHook(_param0 *gits.GitWebHookArguments) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateWebHook", 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 *MockGitProvider) UserAuth() auth.UserAuth {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UserAuth", params, []reflect.Type{reflect.TypeOf((*auth.UserAuth)(nil)).Elem()})
	var ret0 auth.UserAuth
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.UserAuth)
		}
	}
	return ret0
}

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

func (mock *MockGitProvider) ValidateRepositoryName(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGitProvider().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ValidateRepositoryName", 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 *MockGitProvider) VerifyWasCalledOnce() *VerifierMockGitProvider {
	return &VerifierMockGitProvider{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

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

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

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

type VerifierMockGitProvider struct {
	mock                   *MockGitProvider
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

func (verifier *VerifierMockGitProvider) AcceptInvitation(_param0 int64) *MockGitProvider_AcceptInvitation_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AcceptInvitation", params, verifier.timeout)
	return &MockGitProvider_AcceptInvitation_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_AcceptInvitation_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGitProvider_AddCollaborator_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_AddCollaborator_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 *MockGitProvider_AddCollaborator_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 *VerifierMockGitProvider) AddPRComment(_param0 *gits.GitPullRequest, _param1 string) *MockGitProvider_AddPRComment_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddPRComment", params, verifier.timeout)
	return &MockGitProvider_AddPRComment_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_AddPRComment_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGitProvider_BranchArchiveURL_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_BranchArchiveURL_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 *MockGitProvider_BranchArchiveURL_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 *VerifierMockGitProvider) CreateIssue(_param0 string, _param1 string, _param2 *gits.GitIssue) *MockGitProvider_CreateIssue_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateIssue", params, verifier.timeout)
	return &MockGitProvider_CreateIssue_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_CreateIssue_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGitProvider_CreateIssueComment_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockGitProvider) CreatePullRequest(_param0 *gits.GitPullRequestArguments) *MockGitProvider_CreatePullRequest_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreatePullRequest", params, verifier.timeout)
	return &MockGitProvider_CreatePullRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_CreatePullRequest_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_CreatePullRequest_OngoingVerification) GetCapturedArguments() *gits.GitPullRequestArguments {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

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

type MockGitProvider_CreateRepository_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockGitProvider) CreateWebHook(_param0 *gits.GitWebHookArguments) *MockGitProvider_CreateWebHook_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateWebHook", params, verifier.timeout)
	return &MockGitProvider_CreateWebHook_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_CreateWebHook_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_CreateWebHook_OngoingVerification) GetCapturedArguments() *gits.GitWebHookArguments {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

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

type MockGitProvider_CurrentUsername_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_CurrentUsername_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_CurrentUsername_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_DeleteRepository_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_DeleteRepository_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 *VerifierMockGitProvider) ForkRepository(_param0 string, _param1 string, _param2 string) *MockGitProvider_ForkRepository_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ForkRepository", params, verifier.timeout)
	return &MockGitProvider_ForkRepository_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_ForkRepository_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_ForkRepository_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 *MockGitProvider_ForkRepository_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 *VerifierMockGitProvider) GetContent(_param0 string, _param1 string, _param2 string, _param3 string) *MockGitProvider_GetContent_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetContent", params, verifier.timeout)
	return &MockGitProvider_GetContent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_GetContent_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_GetContent_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(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)
		}
		_param3 = make([]string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
	}
	return
}

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

type MockGitProvider_GetIssue_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockGitProvider) GetPullRequest(_param0 string, _param1 *gits.GitRepository, _param2 int) *MockGitProvider_GetPullRequest_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetPullRequest", params, verifier.timeout)
	return &MockGitProvider_GetPullRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_GetPullRequest_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockGitProvider) GetPullRequestCommits(_param0 string, _param1 *gits.GitRepository, _param2 int) *MockGitProvider_GetPullRequestCommits_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetPullRequestCommits", params, verifier.timeout)
	return &MockGitProvider_GetPullRequestCommits_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_GetPullRequestCommits_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGitProvider_GetRepository_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_GetRepository_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 *VerifierMockGitProvider) HasIssues() *MockGitProvider_HasIssues_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HasIssues", params, verifier.timeout)
	return &MockGitProvider_HasIssues_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_HasIssues_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_HasIssues_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_HasIssues_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_IsBitbucketCloud_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_IsBitbucketCloud_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_IsBitbucketCloud_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_IsBitbucketServer_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_IsBitbucketServer_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_IsBitbucketServer_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_IsGerrit_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_IsGerrit_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_IsGerrit_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_IsGitHub_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_IsGitHub_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_IsGitHub_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_IsGitea_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_IsGitea_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_IsGitea_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_IssueURL_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_IssueURL_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []int, _param3 []bool) {
	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([]int, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(int)
		}
		_param3 = make([]bool, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(bool)
		}
	}
	return
}

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

type MockGitProvider_JenkinsWebHookPath_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_JenkinsWebHookPath_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 *VerifierMockGitProvider) Kind() *MockGitProvider_Kind_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Kind", params, verifier.timeout)
	return &MockGitProvider_Kind_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_Kind_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_Kind_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_Kind_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_Label_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_Label_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_Label_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_ListCommitStatus_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_ListCommitStatus_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 *MockGitProvider_ListCommitStatus_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 *VerifierMockGitProvider) ListCommits(_param0 string, _param1 string, _param2 *gits.ListCommitsArguments) *MockGitProvider_ListCommits_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListCommits", params, verifier.timeout)
	return &MockGitProvider_ListCommits_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_ListCommits_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGitProvider_ListInvitations_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_ListInvitations_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_ListInvitations_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_ListOpenPullRequests_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_ListOpenPullRequests_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 *VerifierMockGitProvider) ListOrganisations() *MockGitProvider_ListOrganisations_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListOrganisations", params, verifier.timeout)
	return &MockGitProvider_ListOrganisations_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_ListOrganisations_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_ListOrganisations_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_ListOrganisations_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_ListReleases_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_ListReleases_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 *VerifierMockGitProvider) ListRepositories(_param0 string) *MockGitProvider_ListRepositories_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListRepositories", params, verifier.timeout)
	return &MockGitProvider_ListRepositories_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_ListRepositories_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_ListRepositories_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 *VerifierMockGitProvider) ListWebHooks(_param0 string, _param1 string) *MockGitProvider_ListWebHooks_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListWebHooks", params, verifier.timeout)
	return &MockGitProvider_ListWebHooks_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_ListWebHooks_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_ListWebHooks_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 *VerifierMockGitProvider) MergePullRequest(_param0 *gits.GitPullRequest, _param1 string) *MockGitProvider_MergePullRequest_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "MergePullRequest", params, verifier.timeout)
	return &MockGitProvider_MergePullRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_MergePullRequest_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockGitProvider) PullRequestLastCommitStatus(_param0 *gits.GitPullRequest) *MockGitProvider_PullRequestLastCommitStatus_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullRequestLastCommitStatus", params, verifier.timeout)
	return &MockGitProvider_PullRequestLastCommitStatus_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_PullRequestLastCommitStatus_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_PullRequestLastCommitStatus_OngoingVerification) GetCapturedArguments() *gits.GitPullRequest {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

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

type MockGitProvider_RenameRepository_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_RenameRepository_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 *MockGitProvider_RenameRepository_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 *VerifierMockGitProvider) SearchIssues(_param0 string, _param1 string, _param2 string) *MockGitProvider_SearchIssues_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchIssues", params, verifier.timeout)
	return &MockGitProvider_SearchIssues_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_SearchIssues_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_SearchIssues_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 *MockGitProvider_SearchIssues_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 *VerifierMockGitProvider) SearchIssuesClosedSince(_param0 string, _param1 string, _param2 time.Time) *MockGitProvider_SearchIssuesClosedSince_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchIssuesClosedSince", params, verifier.timeout)
	return &MockGitProvider_SearchIssuesClosedSince_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_SearchIssuesClosedSince_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGitProvider_ServerURL_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_ServerURL_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_ServerURL_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_ShouldForkForPullRequest_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_ShouldForkForPullRequest_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 *MockGitProvider_ShouldForkForPullRequest_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 *VerifierMockGitProvider) UpdateCommitStatus(_param0 string, _param1 string, _param2 string, _param3 *gits.GitRepoStatus) *MockGitProvider_UpdateCommitStatus_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateCommitStatus", params, verifier.timeout)
	return &MockGitProvider_UpdateCommitStatus_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_UpdateCommitStatus_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_UpdateCommitStatus_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []*gits.GitRepoStatus) {
	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)
		}
		_param3 = make([]*gits.GitRepoStatus, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(*gits.GitRepoStatus)
		}
	}
	return
}

func (verifier *VerifierMockGitProvider) UpdatePullRequestStatus(_param0 *gits.GitPullRequest) *MockGitProvider_UpdatePullRequestStatus_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdatePullRequestStatus", params, verifier.timeout)
	return &MockGitProvider_UpdatePullRequestStatus_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_UpdatePullRequestStatus_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_UpdatePullRequestStatus_OngoingVerification) GetCapturedArguments() *gits.GitPullRequest {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockGitProvider) UpdateRelease(_param0 string, _param1 string, _param2 string, _param3 *gits.GitRelease) *MockGitProvider_UpdateRelease_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateRelease", params, verifier.timeout)
	return &MockGitProvider_UpdateRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_UpdateRelease_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_UpdateRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []*gits.GitRelease) {
	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)
		}
		_param3 = make([]*gits.GitRelease, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(*gits.GitRelease)
		}
	}
	return
}

func (verifier *VerifierMockGitProvider) UpdateWebHook(_param0 *gits.GitWebHookArguments) *MockGitProvider_UpdateWebHook_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateWebHook", params, verifier.timeout)
	return &MockGitProvider_UpdateWebHook_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_UpdateWebHook_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_UpdateWebHook_OngoingVerification) GetCapturedArguments() *gits.GitWebHookArguments {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

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

type MockGitProvider_UserAuth_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGitProvider_UserAuth_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGitProvider_UserAuth_OngoingVerification) GetAllCapturedArguments() {
}

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

type MockGitProvider_UserInfo_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_UserInfo_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 *VerifierMockGitProvider) ValidateRepositoryName(_param0 string, _param1 string) *MockGitProvider_ValidateRepositoryName_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ValidateRepositoryName", params, verifier.timeout)
	return &MockGitProvider_ValidateRepositoryName_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGitProvider_ValidateRepositoryName_OngoingVerification struct {
	mock              *MockGitProvider
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGitProvider_ValidateRepositoryName_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
}