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() *MockGitProvider {
	return &MockGitProvider{fail: pegomock.GlobalFailHandler}
}

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) 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) 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() *VerifierGitProvider {
	return &VerifierGitProvider{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *GitProvider_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 *GitProvider_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 *VerifierGitProvider) CreatePullRequest(_param0 *gits.GitPullRequestArguments) *GitProvider_CreatePullRequest_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreatePullRequest", params, verifier.timeout)
	return &GitProvider_CreatePullRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

func (c *GitProvider_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 *GitProvider_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 *VerifierGitProvider) CreateWebHook(_param0 *gits.GitWebHookArguments) *GitProvider_CreateWebHook_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateWebHook", params, verifier.timeout)
	return &GitProvider_CreateWebHook_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

func (c *GitProvider_CurrentUsername_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_CurrentUsername_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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

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

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

func (c *GitProvider_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 *GitProvider_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 *VerifierGitProvider) GetPullRequest(_param0 string, _param1 *gits.GitRepository, _param2 int) *GitProvider_GetPullRequest_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetPullRequest", params, verifier.timeout)
	return &GitProvider_GetPullRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *GitProvider_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 *GitProvider_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 *VerifierGitProvider) GetPullRequestCommits(_param0 string, _param1 *gits.GitRepository, _param2 int) *GitProvider_GetPullRequestCommits_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetPullRequestCommits", params, verifier.timeout)
	return &GitProvider_GetPullRequestCommits_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

func (c *GitProvider_HasIssues_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_HasIssues_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_IsBitbucketCloud_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_IsBitbucketCloud_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_IsBitbucketServer_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_IsBitbucketServer_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_IsGerrit_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_IsGerrit_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_IsGitHub_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_IsGitHub_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_IsGitea_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_IsGitea_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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

func (c *GitProvider_Kind_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_Kind_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_Label_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_Label_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

func (c *GitProvider_ListInvitations_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_ListInvitations_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

func (c *GitProvider_ListOrganisations_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_ListOrganisations_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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

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

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

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

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

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

func (c *GitProvider_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 *VerifierGitProvider) PullRequestLastCommitStatus(_param0 *gits.GitPullRequest) *GitProvider_PullRequestLastCommitStatus_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullRequestLastCommitStatus", params, verifier.timeout)
	return &GitProvider_PullRequestLastCommitStatus_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

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

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

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

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

func (c *GitProvider_ServerURL_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_ServerURL_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *GitProvider_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 *GitProvider_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 *VerifierGitProvider) UpdatePullRequestStatus(_param0 *gits.GitPullRequest) *GitProvider_UpdatePullRequestStatus_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdatePullRequestStatus", params, verifier.timeout)
	return &GitProvider_UpdatePullRequestStatus_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

func (c *GitProvider_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 *GitProvider_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 *VerifierGitProvider) UpdateWebHook(_param0 *gits.GitWebHookArguments) *GitProvider_UpdateWebHook_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateWebHook", params, verifier.timeout)
	return &GitProvider_UpdateWebHook_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

func (c *GitProvider_UserAuth_OngoingVerification) GetCapturedArguments() {
}

func (c *GitProvider_UserAuth_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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