mock_event_parsing.go

// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/runatlantis/atlantis/server/events (interfaces: EventParsing)

package mocks

import (
	github "github.com/google/go-github/v50/github"
	azuredevops "github.com/mcdafydd/go-azuredevops/azuredevops"
	pegomock "github.com/petergtz/pegomock"
	models "github.com/runatlantis/atlantis/server/events/models"
	go_gitlab "github.com/xanzy/go-gitlab"
	"reflect"
	"time"
)

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

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

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

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

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

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

func (mock *MockEventParsing) ParseAzureDevopsPull(_param0 *azuredevops.GitPullRequest) (models.PullRequest, models.Repo, models.Repo, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseAzureDevopsPull", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.Repo
	var ret2 models.Repo
	var ret3 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(error)
		}
	}
	return ret0, ret1, ret2, ret3
}

func (mock *MockEventParsing) ParseAzureDevopsPullEvent(_param0 azuredevops.Event) (models.PullRequest, models.PullRequestEventType, models.Repo, models.Repo, models.User, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseAzureDevopsPullEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.PullRequestEventType)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.PullRequestEventType
	var ret2 models.Repo
	var ret3 models.Repo
	var ret4 models.User
	var ret5 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.PullRequestEventType)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.Repo)
		}
		if result[4] != nil {
			ret4 = result[4].(models.User)
		}
		if result[5] != nil {
			ret5 = result[5].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4, ret5
}

func (mock *MockEventParsing) ParseAzureDevopsRepo(_param0 *azuredevops.GitRepository) (models.Repo, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseAzureDevopsRepo", params, []reflect.Type{reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.Repo
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.Repo)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockEventParsing) ParseBitbucketCloudPullCommentEvent(_param0 []byte) (models.PullRequest, models.Repo, models.Repo, models.User, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseBitbucketCloudPullCommentEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.Repo
	var ret2 models.Repo
	var ret3 models.User
	var ret4 string
	var ret5 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.User)
		}
		if result[4] != nil {
			ret4 = result[4].(string)
		}
		if result[5] != nil {
			ret5 = result[5].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4, ret5
}

func (mock *MockEventParsing) ParseBitbucketCloudPullEvent(_param0 []byte) (models.PullRequest, models.Repo, models.Repo, models.User, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseBitbucketCloudPullEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.Repo
	var ret2 models.Repo
	var ret3 models.User
	var ret4 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.User)
		}
		if result[4] != nil {
			ret4 = result[4].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4
}

func (mock *MockEventParsing) ParseBitbucketServerPullCommentEvent(_param0 []byte) (models.PullRequest, models.Repo, models.Repo, models.User, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseBitbucketServerPullCommentEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.Repo
	var ret2 models.Repo
	var ret3 models.User
	var ret4 string
	var ret5 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.User)
		}
		if result[4] != nil {
			ret4 = result[4].(string)
		}
		if result[5] != nil {
			ret5 = result[5].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4, ret5
}

func (mock *MockEventParsing) ParseBitbucketServerPullEvent(_param0 []byte) (models.PullRequest, models.Repo, models.Repo, models.User, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseBitbucketServerPullEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.Repo
	var ret2 models.Repo
	var ret3 models.User
	var ret4 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.User)
		}
		if result[4] != nil {
			ret4 = result[4].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4
}

func (mock *MockEventParsing) ParseGithubIssueCommentEvent(_param0 *github.IssueCommentEvent) (models.Repo, models.User, int, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGithubIssueCommentEvent", params, []reflect.Type{reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*int)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.Repo
	var ret1 models.User
	var ret2 int
	var ret3 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.Repo)
		}
		if result[1] != nil {
			ret1 = result[1].(models.User)
		}
		if result[2] != nil {
			ret2 = result[2].(int)
		}
		if result[3] != nil {
			ret3 = result[3].(error)
		}
	}
	return ret0, ret1, ret2, ret3
}

func (mock *MockEventParsing) ParseGithubPull(_param0 *github.PullRequest) (models.PullRequest, models.Repo, models.Repo, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGithubPull", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.Repo
	var ret2 models.Repo
	var ret3 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(error)
		}
	}
	return ret0, ret1, ret2, ret3
}

func (mock *MockEventParsing) ParseGithubPullEvent(_param0 *github.PullRequestEvent) (models.PullRequest, models.PullRequestEventType, models.Repo, models.Repo, models.User, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGithubPullEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.PullRequestEventType)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.PullRequestEventType
	var ret2 models.Repo
	var ret3 models.Repo
	var ret4 models.User
	var ret5 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.PullRequestEventType)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.Repo)
		}
		if result[4] != nil {
			ret4 = result[4].(models.User)
		}
		if result[5] != nil {
			ret5 = result[5].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4, ret5
}

func (mock *MockEventParsing) ParseGithubRepo(_param0 *github.Repository) (models.Repo, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGithubRepo", params, []reflect.Type{reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.Repo
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.Repo)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockEventParsing) ParseGitlabMergeRequest(_param0 *go_gitlab.MergeRequest, _param1 models.Repo) models.PullRequest {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGitlabMergeRequest", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem()})
	var ret0 models.PullRequest
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
	}
	return ret0
}

func (mock *MockEventParsing) ParseGitlabMergeRequestCommentEvent(_param0 go_gitlab.MergeCommentEvent) (models.Repo, models.Repo, models.User, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGitlabMergeRequestCommentEvent", params, []reflect.Type{reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.Repo
	var ret1 models.Repo
	var ret2 models.User
	var ret3 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.Repo)
		}
		if result[1] != nil {
			ret1 = result[1].(models.Repo)
		}
		if result[2] != nil {
			ret2 = result[2].(models.User)
		}
		if result[3] != nil {
			ret3 = result[3].(error)
		}
	}
	return ret0, ret1, ret2, ret3
}

func (mock *MockEventParsing) ParseGitlabMergeRequestEvent(_param0 go_gitlab.MergeEvent) (models.PullRequest, models.PullRequestEventType, models.Repo, models.Repo, models.User, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGitlabMergeRequestEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequest)(nil)).Elem(), reflect.TypeOf((*models.PullRequestEventType)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.Repo)(nil)).Elem(), reflect.TypeOf((*models.User)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 models.PullRequest
	var ret1 models.PullRequestEventType
	var ret2 models.Repo
	var ret3 models.Repo
	var ret4 models.User
	var ret5 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequest)
		}
		if result[1] != nil {
			ret1 = result[1].(models.PullRequestEventType)
		}
		if result[2] != nil {
			ret2 = result[2].(models.Repo)
		}
		if result[3] != nil {
			ret3 = result[3].(models.Repo)
		}
		if result[4] != nil {
			ret4 = result[4].(models.User)
		}
		if result[5] != nil {
			ret5 = result[5].(error)
		}
	}
	return ret0, ret1, ret2, ret3, ret4, ret5
}

func (mock *MockEventParsing) ParseGitlabMergeRequestUpdateEvent(_param0 go_gitlab.MergeEvent) models.PullRequestEventType {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockEventParsing().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ParseGitlabMergeRequestUpdateEvent", params, []reflect.Type{reflect.TypeOf((*models.PullRequestEventType)(nil)).Elem()})
	var ret0 models.PullRequestEventType
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(models.PullRequestEventType)
		}
	}
	return ret0
}

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

func (mock *MockEventParsing) VerifyWasCalled(invocationCountMatcher pegomock.InvocationCountMatcher) *VerifierMockEventParsing {
	return &VerifierMockEventParsing{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
	}
}

func (mock *MockEventParsing) VerifyWasCalledInOrder(invocationCountMatcher pegomock.InvocationCountMatcher, inOrderContext *pegomock.InOrderContext) *VerifierMockEventParsing {
	return &VerifierMockEventParsing{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		inOrderContext:         inOrderContext,
	}
}

func (mock *MockEventParsing) VerifyWasCalledEventually(invocationCountMatcher pegomock.InvocationCountMatcher, timeout time.Duration) *VerifierMockEventParsing {
	return &VerifierMockEventParsing{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		timeout:                timeout,
	}
}

type VerifierMockEventParsing struct {
	mock                   *MockEventParsing
	invocationCountMatcher pegomock.InvocationCountMatcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

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

type MockEventParsing_GetBitbucketCloudPullEventType_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockEventParsing_GetBitbucketServerPullEventType_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseAPIPlanRequest(_param0 models.VCSHostType, _param1 string, _param2 string) *MockEventParsing_ParseAPIPlanRequest_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseAPIPlanRequest", params, verifier.timeout)
	return &MockEventParsing_ParseAPIPlanRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseAPIPlanRequest_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseAzureDevopsPull(_param0 *azuredevops.GitPullRequest) *MockEventParsing_ParseAzureDevopsPull_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseAzureDevopsPull", params, verifier.timeout)
	return &MockEventParsing_ParseAzureDevopsPull_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseAzureDevopsPull_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseAzureDevopsPullEvent(_param0 azuredevops.Event) *MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseAzureDevopsPullEvent", params, verifier.timeout)
	return &MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseAzureDevopsPullEvent_OngoingVerification) GetCapturedArguments() azuredevops.Event {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseAzureDevopsRepo(_param0 *azuredevops.GitRepository) *MockEventParsing_ParseAzureDevopsRepo_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseAzureDevopsRepo", params, verifier.timeout)
	return &MockEventParsing_ParseAzureDevopsRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseAzureDevopsRepo_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseAzureDevopsRepo_OngoingVerification) GetCapturedArguments() *azuredevops.GitRepository {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseBitbucketCloudPullCommentEvent(_param0 []byte) *MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseBitbucketCloudPullCommentEvent", params, verifier.timeout)
	return &MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseBitbucketCloudPullCommentEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseBitbucketCloudPullEvent(_param0 []byte) *MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseBitbucketCloudPullEvent", params, verifier.timeout)
	return &MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseBitbucketCloudPullEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseBitbucketServerPullCommentEvent(_param0 []byte) *MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseBitbucketServerPullCommentEvent", params, verifier.timeout)
	return &MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseBitbucketServerPullCommentEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseBitbucketServerPullEvent(_param0 []byte) *MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseBitbucketServerPullEvent", params, verifier.timeout)
	return &MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseBitbucketServerPullEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockEventParsing) ParseGithubIssueCommentEvent(_param0 *github.IssueCommentEvent) *MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGithubIssueCommentEvent", params, verifier.timeout)
	return &MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGithubIssueCommentEvent_OngoingVerification) GetCapturedArguments() *github.IssueCommentEvent {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGithubPull(_param0 *github.PullRequest) *MockEventParsing_ParseGithubPull_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGithubPull", params, verifier.timeout)
	return &MockEventParsing_ParseGithubPull_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGithubPull_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGithubPull_OngoingVerification) GetCapturedArguments() *github.PullRequest {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGithubPullEvent(_param0 *github.PullRequestEvent) *MockEventParsing_ParseGithubPullEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGithubPullEvent", params, verifier.timeout)
	return &MockEventParsing_ParseGithubPullEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGithubPullEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGithubPullEvent_OngoingVerification) GetCapturedArguments() *github.PullRequestEvent {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGithubRepo(_param0 *github.Repository) *MockEventParsing_ParseGithubRepo_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGithubRepo", params, verifier.timeout)
	return &MockEventParsing_ParseGithubRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGithubRepo_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGithubRepo_OngoingVerification) GetCapturedArguments() *github.Repository {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequest(_param0 *go_gitlab.MergeRequest, _param1 models.Repo) *MockEventParsing_ParseGitlabMergeRequest_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGitlabMergeRequest", params, verifier.timeout)
	return &MockEventParsing_ParseGitlabMergeRequest_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGitlabMergeRequest_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGitlabMergeRequest_OngoingVerification) GetCapturedArguments() (*go_gitlab.MergeRequest, models.Repo) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequestCommentEvent(_param0 go_gitlab.MergeCommentEvent) *MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGitlabMergeRequestCommentEvent", params, verifier.timeout)
	return &MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGitlabMergeRequestCommentEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeCommentEvent {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequestEvent(_param0 go_gitlab.MergeEvent) *MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGitlabMergeRequestEvent", params, verifier.timeout)
	return &MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGitlabMergeRequestEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeEvent {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierMockEventParsing) ParseGitlabMergeRequestUpdateEvent(_param0 go_gitlab.MergeEvent) *MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ParseGitlabMergeRequestUpdateEvent", params, verifier.timeout)
	return &MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification struct {
	mock              *MockEventParsing
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockEventParsing_ParseGitlabMergeRequestUpdateEvent_OngoingVerification) GetCapturedArguments() go_gitlab.MergeEvent {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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