// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"bnema.dev/ermite/internal/domain"
	"bnema.dev/ermite/internal/ports"
	mock "github.com/stretchr/testify/mock"
)

// NewMergeRequestService creates a new instance of MergeRequestService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMergeRequestService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MergeRequestService {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MergeRequestService{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MergeRequestService is an autogenerated mock type for the MergeRequestService type
type MergeRequestService struct {
	mock.Mock
}

type MergeRequestService_Expecter struct {
	mock *mock.Mock
}

func (_m *MergeRequestService) EXPECT() *MergeRequestService_Expecter {
	return &MergeRequestService_Expecter{mock: &_m.Mock}
}

// AddComment provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams) (domain.Comment, error) {
	ret := _mock.Called(ctx, p, name, number, params)

	if len(ret) == 0 {
		panic("no return value specified for AddComment")
	}

	var r0 domain.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.AddCommentParams) (domain.Comment, error)); ok {
		return returnFunc(ctx, p, name, number, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.AddCommentParams) domain.Comment); ok {
		r0 = returnFunc(ctx, p, name, number, params)
	} else {
		r0 = ret.Get(0).(domain.Comment)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.AddCommentParams) error); ok {
		r1 = returnFunc(ctx, p, name, number, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_AddComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddComment'
type MergeRequestService_AddComment_Call struct {
	*mock.Call
}

// AddComment is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - params ports.AddCommentParams
func (_e *MergeRequestService_Expecter) AddComment(ctx any, p any, name any, number any, params any) *MergeRequestService_AddComment_Call {
	return &MergeRequestService_AddComment_Call{Call: _e.mock.On("AddComment", ctx, p, name, number, params)}
}

func (_c *MergeRequestService_AddComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams)) *MergeRequestService_AddComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 ports.AddCommentParams
		if args[4] != nil {
			arg4 = args[4].(ports.AddCommentParams)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_AddComment_Call) Return(comment domain.Comment, err error) *MergeRequestService_AddComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *MergeRequestService_AddComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams) (domain.Comment, error)) *MergeRequestService_AddComment_Call {
	_c.Call.Return(run)
	return _c
}

// CancelAutoMerge provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) CancelAutoMerge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error) {
	ret := _mock.Called(ctx, p, name, number)

	if len(ret) == 0 {
		panic("no return value specified for CancelAutoMerge")
	}

	var r0 domain.MergeRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) (domain.MergeRequest, error)); ok {
		return returnFunc(ctx, p, name, number)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) domain.MergeRequest); ok {
		r0 = returnFunc(ctx, p, name, number)
	} else {
		r0 = ret.Get(0).(domain.MergeRequest)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64) error); ok {
		r1 = returnFunc(ctx, p, name, number)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_CancelAutoMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelAutoMerge'
type MergeRequestService_CancelAutoMerge_Call struct {
	*mock.Call
}

// CancelAutoMerge is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
func (_e *MergeRequestService_Expecter) CancelAutoMerge(ctx any, p any, name any, number any) *MergeRequestService_CancelAutoMerge_Call {
	return &MergeRequestService_CancelAutoMerge_Call{Call: _e.mock.On("CancelAutoMerge", ctx, p, name, number)}
}

func (_c *MergeRequestService_CancelAutoMerge_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64)) *MergeRequestService_CancelAutoMerge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MergeRequestService_CancelAutoMerge_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_CancelAutoMerge_Call {
	_c.Call.Return(mergeRequest, err)
	return _c
}

func (_c *MergeRequestService_CancelAutoMerge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)) *MergeRequestService_CancelAutoMerge_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) Close(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error) {
	ret := _mock.Called(ctx, p, name, number)

	if len(ret) == 0 {
		panic("no return value specified for Close")
	}

	var r0 domain.MergeRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) (domain.MergeRequest, error)); ok {
		return returnFunc(ctx, p, name, number)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) domain.MergeRequest); ok {
		r0 = returnFunc(ctx, p, name, number)
	} else {
		r0 = ret.Get(0).(domain.MergeRequest)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64) error); ok {
		r1 = returnFunc(ctx, p, name, number)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MergeRequestService_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
func (_e *MergeRequestService_Expecter) Close(ctx any, p any, name any, number any) *MergeRequestService_Close_Call {
	return &MergeRequestService_Close_Call{Call: _e.mock.On("Close", ctx, p, name, number)}
}

func (_c *MergeRequestService_Close_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64)) *MergeRequestService_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MergeRequestService_Close_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_Close_Call {
	_c.Call.Return(mergeRequest, err)
	return _c
}

func (_c *MergeRequestService_Close_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)) *MergeRequestService_Close_Call {
	_c.Call.Return(run)
	return _c
}

// Compare provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) Compare(ctx context.Context, p domain.Principal, repo domain.RepoName, target domain.ObjectID, source domain.ObjectID) (ports.CompareResult, error) {
	ret := _mock.Called(ctx, p, repo, target, source)

	if len(ret) == 0 {
		panic("no return value specified for Compare")
	}

	var r0 ports.CompareResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, domain.ObjectID, domain.ObjectID) (ports.CompareResult, error)); ok {
		return returnFunc(ctx, p, repo, target, source)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, domain.ObjectID, domain.ObjectID) ports.CompareResult); ok {
		r0 = returnFunc(ctx, p, repo, target, source)
	} else {
		r0 = ret.Get(0).(ports.CompareResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, domain.ObjectID, domain.ObjectID) error); ok {
		r1 = returnFunc(ctx, p, repo, target, source)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_Compare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Compare'
type MergeRequestService_Compare_Call struct {
	*mock.Call
}

// Compare is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - repo domain.RepoName
//   - target domain.ObjectID
//   - source domain.ObjectID
func (_e *MergeRequestService_Expecter) Compare(ctx any, p any, repo any, target any, source any) *MergeRequestService_Compare_Call {
	return &MergeRequestService_Compare_Call{Call: _e.mock.On("Compare", ctx, p, repo, target, source)}
}

func (_c *MergeRequestService_Compare_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, target domain.ObjectID, source domain.ObjectID)) *MergeRequestService_Compare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 domain.ObjectID
		if args[3] != nil {
			arg3 = args[3].(domain.ObjectID)
		}
		var arg4 domain.ObjectID
		if args[4] != nil {
			arg4 = args[4].(domain.ObjectID)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_Compare_Call) Return(compareResult ports.CompareResult, err error) *MergeRequestService_Compare_Call {
	_c.Call.Return(compareResult, err)
	return _c
}

func (_c *MergeRequestService_Compare_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, target domain.ObjectID, source domain.ObjectID) (ports.CompareResult, error)) *MergeRequestService_Compare_Call {
	_c.Call.Return(run)
	return _c
}

// CountOpen provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) CountOpen(ctx context.Context, p domain.Principal, name domain.RepoName) (int, error) {
	ret := _mock.Called(ctx, p, name)

	if len(ret) == 0 {
		panic("no return value specified for CountOpen")
	}

	var r0 int
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) (int, error)); ok {
		return returnFunc(ctx, p, name)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) int); ok {
		r0 = returnFunc(ctx, p, name)
	} else {
		r0 = ret.Get(0).(int)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName) error); ok {
		r1 = returnFunc(ctx, p, name)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_CountOpen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountOpen'
type MergeRequestService_CountOpen_Call struct {
	*mock.Call
}

// CountOpen is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
func (_e *MergeRequestService_Expecter) CountOpen(ctx any, p any, name any) *MergeRequestService_CountOpen_Call {
	return &MergeRequestService_CountOpen_Call{Call: _e.mock.On("CountOpen", ctx, p, name)}
}

func (_c *MergeRequestService_CountOpen_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) *MergeRequestService_CountOpen_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MergeRequestService_CountOpen_Call) Return(n int, err error) *MergeRequestService_CountOpen_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MergeRequestService_CountOpen_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) (int, error)) *MergeRequestService_CountOpen_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) Create(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams) (domain.MergeRequest, error) {
	ret := _mock.Called(ctx, p, name, params)

	if len(ret) == 0 {
		panic("no return value specified for Create")
	}

	var r0 domain.MergeRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.CreateMergeRequestParams) (domain.MergeRequest, error)); ok {
		return returnFunc(ctx, p, name, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.CreateMergeRequestParams) domain.MergeRequest); ok {
		r0 = returnFunc(ctx, p, name, params)
	} else {
		r0 = ret.Get(0).(domain.MergeRequest)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.CreateMergeRequestParams) error); ok {
		r1 = returnFunc(ctx, p, name, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
type MergeRequestService_Create_Call struct {
	*mock.Call
}

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - params ports.CreateMergeRequestParams
func (_e *MergeRequestService_Expecter) Create(ctx any, p any, name any, params any) *MergeRequestService_Create_Call {
	return &MergeRequestService_Create_Call{Call: _e.mock.On("Create", ctx, p, name, params)}
}

func (_c *MergeRequestService_Create_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams)) *MergeRequestService_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 ports.CreateMergeRequestParams
		if args[3] != nil {
			arg3 = args[3].(ports.CreateMergeRequestParams)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MergeRequestService_Create_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_Create_Call {
	_c.Call.Return(mergeRequest, err)
	return _c
}

func (_c *MergeRequestService_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams) (domain.MergeRequest, error)) *MergeRequestService_Create_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteComment provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) DeleteComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64) (domain.Comment, error) {
	ret := _mock.Called(ctx, p, name, number, commentID)

	if len(ret) == 0 {
		panic("no return value specified for DeleteComment")
	}

	var r0 domain.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int64) (domain.Comment, error)); ok {
		return returnFunc(ctx, p, name, number, commentID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int64) domain.Comment); ok {
		r0 = returnFunc(ctx, p, name, number, commentID)
	} else {
		r0 = ret.Get(0).(domain.Comment)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, int64) error); ok {
		r1 = returnFunc(ctx, p, name, number, commentID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_DeleteComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteComment'
type MergeRequestService_DeleteComment_Call struct {
	*mock.Call
}

// DeleteComment is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - commentID int64
func (_e *MergeRequestService_Expecter) DeleteComment(ctx any, p any, name any, number any, commentID any) *MergeRequestService_DeleteComment_Call {
	return &MergeRequestService_DeleteComment_Call{Call: _e.mock.On("DeleteComment", ctx, p, name, number, commentID)}
}

func (_c *MergeRequestService_DeleteComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64)) *MergeRequestService_DeleteComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_DeleteComment_Call) Return(comment domain.Comment, err error) *MergeRequestService_DeleteComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *MergeRequestService_DeleteComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64) (domain.Comment, error)) *MergeRequestService_DeleteComment_Call {
	_c.Call.Return(run)
	return _c
}

// EditComment provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) EditComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, text string) (domain.Comment, error) {
	ret := _mock.Called(ctx, p, name, number, commentID, text)

	if len(ret) == 0 {
		panic("no return value specified for EditComment")
	}

	var r0 domain.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int64, string) (domain.Comment, error)); ok {
		return returnFunc(ctx, p, name, number, commentID, text)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int64, string) domain.Comment); ok {
		r0 = returnFunc(ctx, p, name, number, commentID, text)
	} else {
		r0 = ret.Get(0).(domain.Comment)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, int64, string) error); ok {
		r1 = returnFunc(ctx, p, name, number, commentID, text)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_EditComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EditComment'
type MergeRequestService_EditComment_Call struct {
	*mock.Call
}

// EditComment is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - commentID int64
//   - text string
func (_e *MergeRequestService_Expecter) EditComment(ctx any, p any, name any, number any, commentID any, text any) *MergeRequestService_EditComment_Call {
	return &MergeRequestService_EditComment_Call{Call: _e.mock.On("EditComment", ctx, p, name, number, commentID, text)}
}

func (_c *MergeRequestService_EditComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, text string)) *MergeRequestService_EditComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *MergeRequestService_EditComment_Call) Return(comment domain.Comment, err error) *MergeRequestService_EditComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *MergeRequestService_EditComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, text string) (domain.Comment, error)) *MergeRequestService_EditComment_Call {
	_c.Call.Return(run)
	return _c
}

// EnableAutoMerge provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) EnableAutoMerge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.EnableAutoMergeParams) (domain.MergeRequest, error) {
	ret := _mock.Called(ctx, p, name, number, params)

	if len(ret) == 0 {
		panic("no return value specified for EnableAutoMerge")
	}

	var r0 domain.MergeRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.EnableAutoMergeParams) (domain.MergeRequest, error)); ok {
		return returnFunc(ctx, p, name, number, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.EnableAutoMergeParams) domain.MergeRequest); ok {
		r0 = returnFunc(ctx, p, name, number, params)
	} else {
		r0 = ret.Get(0).(domain.MergeRequest)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.EnableAutoMergeParams) error); ok {
		r1 = returnFunc(ctx, p, name, number, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_EnableAutoMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableAutoMerge'
type MergeRequestService_EnableAutoMerge_Call struct {
	*mock.Call
}

// EnableAutoMerge is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - params ports.EnableAutoMergeParams
func (_e *MergeRequestService_Expecter) EnableAutoMerge(ctx any, p any, name any, number any, params any) *MergeRequestService_EnableAutoMerge_Call {
	return &MergeRequestService_EnableAutoMerge_Call{Call: _e.mock.On("EnableAutoMerge", ctx, p, name, number, params)}
}

func (_c *MergeRequestService_EnableAutoMerge_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.EnableAutoMergeParams)) *MergeRequestService_EnableAutoMerge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 ports.EnableAutoMergeParams
		if args[4] != nil {
			arg4 = args[4].(ports.EnableAutoMergeParams)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_EnableAutoMerge_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_EnableAutoMerge_Call {
	_c.Call.Return(mergeRequest, err)
	return _c
}

func (_c *MergeRequestService_EnableAutoMerge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.EnableAutoMergeParams) (domain.MergeRequest, error)) *MergeRequestService_EnableAutoMerge_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, opts ports.GetMergeRequestOptions) (ports.MergeRequestDetail, error) {
	ret := _mock.Called(ctx, p, name, number, opts)

	if len(ret) == 0 {
		panic("no return value specified for Get")
	}

	var r0 ports.MergeRequestDetail
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.GetMergeRequestOptions) (ports.MergeRequestDetail, error)); ok {
		return returnFunc(ctx, p, name, number, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.GetMergeRequestOptions) ports.MergeRequestDetail); ok {
		r0 = returnFunc(ctx, p, name, number, opts)
	} else {
		r0 = ret.Get(0).(ports.MergeRequestDetail)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.GetMergeRequestOptions) error); ok {
		r1 = returnFunc(ctx, p, name, number, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
type MergeRequestService_Get_Call struct {
	*mock.Call
}

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - opts ports.GetMergeRequestOptions
func (_e *MergeRequestService_Expecter) Get(ctx any, p any, name any, number any, opts any) *MergeRequestService_Get_Call {
	return &MergeRequestService_Get_Call{Call: _e.mock.On("Get", ctx, p, name, number, opts)}
}

func (_c *MergeRequestService_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, opts ports.GetMergeRequestOptions)) *MergeRequestService_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 ports.GetMergeRequestOptions
		if args[4] != nil {
			arg4 = args[4].(ports.GetMergeRequestOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_Get_Call) Return(mergeRequestDetail ports.MergeRequestDetail, err error) *MergeRequestService_Get_Call {
	_c.Call.Return(mergeRequestDetail, err)
	return _c
}

func (_c *MergeRequestService_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, opts ports.GetMergeRequestOptions) (ports.MergeRequestDetail, error)) *MergeRequestService_Get_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) List(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams) (ports.MergeRequestPage, error) {
	ret := _mock.Called(ctx, p, name, params)

	if len(ret) == 0 {
		panic("no return value specified for List")
	}

	var r0 ports.MergeRequestPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListMergeRequestsParams) (ports.MergeRequestPage, error)); ok {
		return returnFunc(ctx, p, name, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListMergeRequestsParams) ports.MergeRequestPage); ok {
		r0 = returnFunc(ctx, p, name, params)
	} else {
		r0 = ret.Get(0).(ports.MergeRequestPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.ListMergeRequestsParams) error); ok {
		r1 = returnFunc(ctx, p, name, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
type MergeRequestService_List_Call struct {
	*mock.Call
}

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - params ports.ListMergeRequestsParams
func (_e *MergeRequestService_Expecter) List(ctx any, p any, name any, params any) *MergeRequestService_List_Call {
	return &MergeRequestService_List_Call{Call: _e.mock.On("List", ctx, p, name, params)}
}

func (_c *MergeRequestService_List_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams)) *MergeRequestService_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 ports.ListMergeRequestsParams
		if args[3] != nil {
			arg3 = args[3].(ports.ListMergeRequestsParams)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MergeRequestService_List_Call) Return(mergeRequestPage ports.MergeRequestPage, err error) *MergeRequestService_List_Call {
	_c.Call.Return(mergeRequestPage, err)
	return _c
}

func (_c *MergeRequestService_List_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams) (ports.MergeRequestPage, error)) *MergeRequestService_List_Call {
	_c.Call.Return(run)
	return _c
}

// MarkRead provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) MarkRead(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error) {
	ret := _mock.Called(ctx, p, name, number, head)

	if len(ret) == 0 {
		panic("no return value specified for MarkRead")
	}

	var r0 domain.ObjectID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, domain.ObjectID) (domain.ObjectID, error)); ok {
		return returnFunc(ctx, p, name, number, head)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, domain.ObjectID) domain.ObjectID); ok {
		r0 = returnFunc(ctx, p, name, number, head)
	} else {
		r0 = ret.Get(0).(domain.ObjectID)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, domain.ObjectID) error); ok {
		r1 = returnFunc(ctx, p, name, number, head)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_MarkRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkRead'
type MergeRequestService_MarkRead_Call struct {
	*mock.Call
}

// MarkRead is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - head domain.ObjectID
func (_e *MergeRequestService_Expecter) MarkRead(ctx any, p any, name any, number any, head any) *MergeRequestService_MarkRead_Call {
	return &MergeRequestService_MarkRead_Call{Call: _e.mock.On("MarkRead", ctx, p, name, number, head)}
}

func (_c *MergeRequestService_MarkRead_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID)) *MergeRequestService_MarkRead_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 domain.ObjectID
		if args[4] != nil {
			arg4 = args[4].(domain.ObjectID)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_MarkRead_Call) Return(objectID domain.ObjectID, err error) *MergeRequestService_MarkRead_Call {
	_c.Call.Return(objectID, err)
	return _c
}

func (_c *MergeRequestService_MarkRead_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error)) *MergeRequestService_MarkRead_Call {
	_c.Call.Return(run)
	return _c
}

// MarkReady provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) MarkReady(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error) {
	ret := _mock.Called(ctx, p, name, number)

	if len(ret) == 0 {
		panic("no return value specified for MarkReady")
	}

	var r0 domain.MergeRequest
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) (domain.MergeRequest, error)); ok {
		return returnFunc(ctx, p, name, number)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) domain.MergeRequest); ok {
		r0 = returnFunc(ctx, p, name, number)
	} else {
		r0 = ret.Get(0).(domain.MergeRequest)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64) error); ok {
		r1 = returnFunc(ctx, p, name, number)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_MarkReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkReady'
type MergeRequestService_MarkReady_Call struct {
	*mock.Call
}

// MarkReady is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
func (_e *MergeRequestService_Expecter) MarkReady(ctx any, p any, name any, number any) *MergeRequestService_MarkReady_Call {
	return &MergeRequestService_MarkReady_Call{Call: _e.mock.On("MarkReady", ctx, p, name, number)}
}

func (_c *MergeRequestService_MarkReady_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64)) *MergeRequestService_MarkReady_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MergeRequestService_MarkReady_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_MarkReady_Call {
	_c.Call.Return(mergeRequest, err)
	return _c
}

func (_c *MergeRequestService_MarkReady_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)) *MergeRequestService_MarkReady_Call {
	_c.Call.Return(run)
	return _c
}

// Merge provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams) (ports.MergeResult, error) {
	ret := _mock.Called(ctx, p, name, number, params)

	if len(ret) == 0 {
		panic("no return value specified for Merge")
	}

	var r0 ports.MergeResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.MergeParams) (ports.MergeResult, error)); ok {
		return returnFunc(ctx, p, name, number, params)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.MergeParams) ports.MergeResult); ok {
		r0 = returnFunc(ctx, p, name, number, params)
	} else {
		r0 = ret.Get(0).(ports.MergeResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.MergeParams) error); ok {
		r1 = returnFunc(ctx, p, name, number, params)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_Merge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Merge'
type MergeRequestService_Merge_Call struct {
	*mock.Call
}

// Merge is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - params ports.MergeParams
func (_e *MergeRequestService_Expecter) Merge(ctx any, p any, name any, number any, params any) *MergeRequestService_Merge_Call {
	return &MergeRequestService_Merge_Call{Call: _e.mock.On("Merge", ctx, p, name, number, params)}
}

func (_c *MergeRequestService_Merge_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams)) *MergeRequestService_Merge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 ports.MergeParams
		if args[4] != nil {
			arg4 = args[4].(ports.MergeParams)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_Merge_Call) Return(mergeResult ports.MergeResult, err error) *MergeRequestService_Merge_Call {
	_c.Call.Return(mergeResult, err)
	return _c
}

func (_c *MergeRequestService_Merge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams) (ports.MergeResult, error)) *MergeRequestService_Merge_Call {
	_c.Call.Return(run)
	return _c
}

// Mergeability provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) Mergeability(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.Mergeability, error) {
	ret := _mock.Called(ctx, p, name, number)

	if len(ret) == 0 {
		panic("no return value specified for Mergeability")
	}

	var r0 domain.Mergeability
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) (domain.Mergeability, error)); ok {
		return returnFunc(ctx, p, name, number)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) domain.Mergeability); ok {
		r0 = returnFunc(ctx, p, name, number)
	} else {
		r0 = ret.Get(0).(domain.Mergeability)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64) error); ok {
		r1 = returnFunc(ctx, p, name, number)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_Mergeability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Mergeability'
type MergeRequestService_Mergeability_Call struct {
	*mock.Call
}

// Mergeability is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
func (_e *MergeRequestService_Expecter) Mergeability(ctx any, p any, name any, number any) *MergeRequestService_Mergeability_Call {
	return &MergeRequestService_Mergeability_Call{Call: _e.mock.On("Mergeability", ctx, p, name, number)}
}

func (_c *MergeRequestService_Mergeability_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64)) *MergeRequestService_Mergeability_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MergeRequestService_Mergeability_Call) Return(mergeability domain.Mergeability, err error) *MergeRequestService_Mergeability_Call {
	_c.Call.Return(mergeability, err)
	return _c
}

func (_c *MergeRequestService_Mergeability_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.Mergeability, error)) *MergeRequestService_Mergeability_Call {
	_c.Call.Return(run)
	return _c
}

// PushSummary provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) PushSummary(ctx context.Context, p domain.Principal, repo domain.RepoName, oldHead domain.ObjectID, newTip domain.ObjectID) (ports.PushSummary, error) {
	ret := _mock.Called(ctx, p, repo, oldHead, newTip)

	if len(ret) == 0 {
		panic("no return value specified for PushSummary")
	}

	var r0 ports.PushSummary
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, domain.ObjectID, domain.ObjectID) (ports.PushSummary, error)); ok {
		return returnFunc(ctx, p, repo, oldHead, newTip)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, domain.ObjectID, domain.ObjectID) ports.PushSummary); ok {
		r0 = returnFunc(ctx, p, repo, oldHead, newTip)
	} else {
		r0 = ret.Get(0).(ports.PushSummary)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, domain.ObjectID, domain.ObjectID) error); ok {
		r1 = returnFunc(ctx, p, repo, oldHead, newTip)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_PushSummary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PushSummary'
type MergeRequestService_PushSummary_Call struct {
	*mock.Call
}

// PushSummary is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - repo domain.RepoName
//   - oldHead domain.ObjectID
//   - newTip domain.ObjectID
func (_e *MergeRequestService_Expecter) PushSummary(ctx any, p any, repo any, oldHead any, newTip any) *MergeRequestService_PushSummary_Call {
	return &MergeRequestService_PushSummary_Call{Call: _e.mock.On("PushSummary", ctx, p, repo, oldHead, newTip)}
}

func (_c *MergeRequestService_PushSummary_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, oldHead domain.ObjectID, newTip domain.ObjectID)) *MergeRequestService_PushSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 domain.ObjectID
		if args[3] != nil {
			arg3 = args[3].(domain.ObjectID)
		}
		var arg4 domain.ObjectID
		if args[4] != nil {
			arg4 = args[4].(domain.ObjectID)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MergeRequestService_PushSummary_Call) Return(pushSummary ports.PushSummary, err error) *MergeRequestService_PushSummary_Call {
	_c.Call.Return(pushSummary, err)
	return _c
}

func (_c *MergeRequestService_PushSummary_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, oldHead domain.ObjectID, newTip domain.ObjectID) (ports.PushSummary, error)) *MergeRequestService_PushSummary_Call {
	_c.Call.Return(run)
	return _c
}

// ResolveComment provides a mock function for the type MergeRequestService
func (_mock *MergeRequestService) ResolveComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool) (domain.Comment, error) {
	ret := _mock.Called(ctx, p, name, number, commentID, resolved)

	if len(ret) == 0 {
		panic("no return value specified for ResolveComment")
	}

	var r0 domain.Comment
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int64, bool) (domain.Comment, error)); ok {
		return returnFunc(ctx, p, name, number, commentID, resolved)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int64, bool) domain.Comment); ok {
		r0 = returnFunc(ctx, p, name, number, commentID, resolved)
	} else {
		r0 = ret.Get(0).(domain.Comment)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, int64, bool) error); ok {
		r1 = returnFunc(ctx, p, name, number, commentID, resolved)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MergeRequestService_ResolveComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveComment'
type MergeRequestService_ResolveComment_Call struct {
	*mock.Call
}

// ResolveComment is a helper method to define mock.On call
//   - ctx context.Context
//   - p domain.Principal
//   - name domain.RepoName
//   - number int64
//   - commentID int64
//   - resolved bool
func (_e *MergeRequestService_Expecter) ResolveComment(ctx any, p any, name any, number any, commentID any, resolved any) *MergeRequestService_ResolveComment_Call {
	return &MergeRequestService_ResolveComment_Call{Call: _e.mock.On("ResolveComment", ctx, p, name, number, commentID, resolved)}
}

func (_c *MergeRequestService_ResolveComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool)) *MergeRequestService_ResolveComment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.Principal
		if args[1] != nil {
			arg1 = args[1].(domain.Principal)
		}
		var arg2 domain.RepoName
		if args[2] != nil {
			arg2 = args[2].(domain.RepoName)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		var arg5 bool
		if args[5] != nil {
			arg5 = args[5].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *MergeRequestService_ResolveComment_Call) Return(comment domain.Comment, err error) *MergeRequestService_ResolveComment_Call {
	_c.Call.Return(comment, err)
	return _c
}

func (_c *MergeRequestService_ResolveComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool) (domain.Comment, error)) *MergeRequestService_ResolveComment_Call {
	_c.Call.Return(run)
	return _c
}