// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/api/client-go (interfaces: MergeRequestsServiceInterface)
//
// Generated by this command:
//
//	mockgen -typed -destination=merge_requests_mock.go -write_package_comment=false -package=testing gitlab.com/gitlab-org/api/client-go MergeRequestsServiceInterface
//

package testing

import (
	reflect "reflect"

	gitlab "gitlab.com/gitlab-org/api/client-go"
	gomock "go.uber.org/mock/gomock"
)

// MockMergeRequestsServiceInterface is a mock of MergeRequestsServiceInterface interface.
type MockMergeRequestsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockMergeRequestsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockMergeRequestsServiceInterfaceMockRecorder is the mock recorder for MockMergeRequestsServiceInterface.
type MockMergeRequestsServiceInterfaceMockRecorder struct {
	mock *MockMergeRequestsServiceInterface
}

// NewMockMergeRequestsServiceInterface creates a new mock instance.
func NewMockMergeRequestsServiceInterface(ctrl *gomock.Controller) *MockMergeRequestsServiceInterface {
	mock := &MockMergeRequestsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockMergeRequestsServiceInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMergeRequestsServiceInterface) EXPECT() *MockMergeRequestsServiceInterfaceMockRecorder {
	return m.recorder
}

// AcceptMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) AcceptMergeRequest(pid any, mergeRequest int64, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AcceptMergeRequest indicates an expected call of AcceptMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) AcceptMergeRequest(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).AcceptMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceAcceptMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceAcceptMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceAcceptMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall) Do(f func(any, int64, *gitlab.AcceptMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall) DoAndReturn(f func(any, int64, *gitlab.AcceptMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceAcceptMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddSpentTime mocks base method.
func (m *MockMergeRequestsServiceInterface) AddSpentTime(pid any, mergeRequest int64, opt *gitlab.AddSpentTimeOptions, options ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddSpentTime", varargs...)
	ret0, _ := ret[0].(*gitlab.TimeStats)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddSpentTime indicates an expected call of AddSpentTime.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) AddSpentTime(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceAddSpentTimeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSpentTime", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).AddSpentTime), varargs...)
	return &MockMergeRequestsServiceInterfaceAddSpentTimeCall{Call: call}
}

// MockMergeRequestsServiceInterfaceAddSpentTimeCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceAddSpentTimeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceAddSpentTimeCall) Return(arg0 *gitlab.TimeStats, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceAddSpentTimeCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceAddSpentTimeCall) Do(f func(any, int64, *gitlab.AddSpentTimeOptions, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceAddSpentTimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceAddSpentTimeCall) DoAndReturn(f func(any, int64, *gitlab.AddSpentTimeOptions, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceAddSpentTimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CancelMergeWhenPipelineSucceeds mocks base method.
func (m *MockMergeRequestsServiceInterface) CancelMergeWhenPipelineSucceeds(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelMergeWhenPipelineSucceeds", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CancelMergeWhenPipelineSucceeds indicates an expected call of CancelMergeWhenPipelineSucceeds.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) CancelMergeWhenPipelineSucceeds(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMergeWhenPipelineSucceeds", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).CancelMergeWhenPipelineSucceeds), varargs...)
	return &MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCancelMergeWhenPipelineSucceedsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) CreateMergeRequest(pid any, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateMergeRequest indicates an expected call of CreateMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) CreateMergeRequest(pid, opt any, options ...any) *MockMergeRequestsServiceInterfaceCreateMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).CreateMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceCreateMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceCreateMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceCreateMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceCreateMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestCall) Do(f func(any, *gitlab.CreateMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestCall) DoAndReturn(f func(any, *gitlab.CreateMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateMergeRequestDependency mocks base method.
func (m *MockMergeRequestsServiceInterface) CreateMergeRequestDependency(pid any, mergeRequest int64, opts gitlab.CreateMergeRequestDependencyOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestDependency, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opts}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMergeRequestDependency", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequestDependency)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateMergeRequestDependency indicates an expected call of CreateMergeRequestDependency.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) CreateMergeRequestDependency(pid, mergeRequest, opts any, options ...any) *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opts}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestDependency", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).CreateMergeRequestDependency), varargs...)
	return &MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall{Call: call}
}

// MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall) Return(arg0 *gitlab.MergeRequestDependency, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall) Do(f func(any, int64, gitlab.CreateMergeRequestDependencyOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestDependency, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall) DoAndReturn(f func(any, int64, gitlab.CreateMergeRequestDependencyOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestDependency, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateMergeRequestDependencyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateMergeRequestPipeline mocks base method.
func (m *MockMergeRequestsServiceInterface) CreateMergeRequestPipeline(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.PipelineInfo, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMergeRequestPipeline", varargs...)
	ret0, _ := ret[0].(*gitlab.PipelineInfo)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateMergeRequestPipeline indicates an expected call of CreateMergeRequestPipeline.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) CreateMergeRequestPipeline(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestPipeline", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).CreateMergeRequestPipeline), varargs...)
	return &MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall{Call: call}
}

// MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall) Return(arg0 *gitlab.PipelineInfo, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.PipelineInfo, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.PipelineInfo, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateMergeRequestPipelineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateTodo mocks base method.
func (m *MockMergeRequestsServiceInterface) CreateTodo(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.Todo, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTodo", varargs...)
	ret0, _ := ret[0].(*gitlab.Todo)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateTodo indicates an expected call of CreateTodo.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) CreateTodo(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceCreateTodoCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTodo", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).CreateTodo), varargs...)
	return &MockMergeRequestsServiceInterfaceCreateTodoCall{Call: call}
}

// MockMergeRequestsServiceInterfaceCreateTodoCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceCreateTodoCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceCreateTodoCall) Return(arg0 *gitlab.Todo, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceCreateTodoCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceCreateTodoCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.Todo, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateTodoCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceCreateTodoCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.Todo, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceCreateTodoCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) DeleteMergeRequest(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMergeRequest indicates an expected call of DeleteMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) DeleteMergeRequest(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).DeleteMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceDeleteMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceDeleteMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceDeleteMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall) Return(arg0 *gitlab.Response, arg1 error) *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockMergeRequestsServiceInterfaceDeleteMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteMergeRequestDependency mocks base method.
func (m *MockMergeRequestsServiceInterface) DeleteMergeRequestDependency(pid any, mergeRequest, blockingMergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, blockingMergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMergeRequestDependency", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMergeRequestDependency indicates an expected call of DeleteMergeRequestDependency.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) DeleteMergeRequestDependency(pid, mergeRequest, blockingMergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, blockingMergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestDependency", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).DeleteMergeRequestDependency), varargs...)
	return &MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall{Call: call}
}

// MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall) Return(arg0 *gitlab.Response, arg1 error) *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall) Do(f func(any, int64, int64, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall) DoAndReturn(f func(any, int64, int64, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockMergeRequestsServiceInterfaceDeleteMergeRequestDependencyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetIssuesClosedOnMerge mocks base method.
func (m *MockMergeRequestsServiceInterface) GetIssuesClosedOnMerge(pid any, mergeRequest int64, opt *gitlab.GetIssuesClosedOnMergeOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIssuesClosedOnMerge", varargs...)
	ret0, _ := ret[0].([]*gitlab.Issue)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetIssuesClosedOnMerge indicates an expected call of GetIssuesClosedOnMerge.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetIssuesClosedOnMerge(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssuesClosedOnMerge", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetIssuesClosedOnMerge), varargs...)
	return &MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall) Return(arg0 []*gitlab.Issue, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall) Do(f func(any, int64, *gitlab.GetIssuesClosedOnMergeOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall) DoAndReturn(f func(any, int64, *gitlab.GetIssuesClosedOnMergeOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetIssuesClosedOnMergeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequest(pid any, mergeRequest int64, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequest indicates an expected call of GetMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequest(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestCall) Do(f func(any, int64, *gitlab.GetMergeRequestsOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestCall) DoAndReturn(f func(any, int64, *gitlab.GetMergeRequestsOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestApprovals mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestApprovals(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestApprovals", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequestApprovals)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestApprovals indicates an expected call of GetMergeRequestApprovals.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestApprovals(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestApprovals", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestApprovals), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall) Return(arg0 *gitlab.MergeRequestApprovals, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestApprovalsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestChanges mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestChanges(pid any, mergeRequest int64, opt *gitlab.GetMergeRequestChangesOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestChanges", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestChanges indicates an expected call of GetMergeRequestChanges.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestChanges(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestChanges", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestChanges), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall) Do(f func(any, int64, *gitlab.GetMergeRequestChangesOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall) DoAndReturn(f func(any, int64, *gitlab.GetMergeRequestChangesOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestChangesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestCommits mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestCommits(pid any, mergeRequest int64, opt *gitlab.GetMergeRequestCommitsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Commit, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestCommits", varargs...)
	ret0, _ := ret[0].([]*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestCommits indicates an expected call of GetMergeRequestCommits.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestCommits(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestCommits", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestCommits), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall) Return(arg0 []*gitlab.Commit, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall) Do(f func(any, int64, *gitlab.GetMergeRequestCommitsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Commit, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall) DoAndReturn(f func(any, int64, *gitlab.GetMergeRequestCommitsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Commit, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestDependencies mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestDependencies(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) ([]gitlab.MergeRequestDependency, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestDependencies", varargs...)
	ret0, _ := ret[0].([]gitlab.MergeRequestDependency)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestDependencies indicates an expected call of GetMergeRequestDependencies.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestDependencies(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestDependencies", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestDependencies), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall) Return(arg0 []gitlab.MergeRequestDependency, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) ([]gitlab.MergeRequestDependency, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) ([]gitlab.MergeRequestDependency, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestDependenciesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestDiffVersions mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestDiffVersions(pid any, mergeRequest int64, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestDiffVersions", varargs...)
	ret0, _ := ret[0].([]*gitlab.MergeRequestDiffVersion)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestDiffVersions indicates an expected call of GetMergeRequestDiffVersions.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestDiffVersions(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestDiffVersions", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestDiffVersions), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall) Return(arg0 []*gitlab.MergeRequestDiffVersion, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall) Do(f func(any, int64, *gitlab.GetMergeRequestDiffVersionsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall) DoAndReturn(f func(any, int64, *gitlab.GetMergeRequestDiffVersionsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestDiffVersionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestParticipants mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestParticipants(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicUser, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestParticipants", varargs...)
	ret0, _ := ret[0].([]*gitlab.BasicUser)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestParticipants indicates an expected call of GetMergeRequestParticipants.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestParticipants(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestParticipants", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestParticipants), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall) Return(arg0 []*gitlab.BasicUser, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicUser, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicUser, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestParticipantsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetMergeRequestReviewers mocks base method.
func (m *MockMergeRequestsServiceInterface) GetMergeRequestReviewers(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestReviewer, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMergeRequestReviewers", varargs...)
	ret0, _ := ret[0].([]*gitlab.MergeRequestReviewer)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMergeRequestReviewers indicates an expected call of GetMergeRequestReviewers.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetMergeRequestReviewers(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestReviewers", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetMergeRequestReviewers), varargs...)
	return &MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall) Return(arg0 []*gitlab.MergeRequestReviewer, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestReviewer, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestReviewer, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetMergeRequestReviewersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetSingleMergeRequestDiffVersion mocks base method.
func (m *MockMergeRequestsServiceInterface) GetSingleMergeRequestDiffVersion(pid any, mergeRequest, version int64, opt *gitlab.GetSingleMergeRequestDiffVersionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestDiffVersion, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, version, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSingleMergeRequestDiffVersion", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequestDiffVersion)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSingleMergeRequestDiffVersion indicates an expected call of GetSingleMergeRequestDiffVersion.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetSingleMergeRequestDiffVersion(pid, mergeRequest, version, opt any, options ...any) *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, version, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSingleMergeRequestDiffVersion", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetSingleMergeRequestDiffVersion), varargs...)
	return &MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall) Return(arg0 *gitlab.MergeRequestDiffVersion, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall) Do(f func(any, int64, int64, *gitlab.GetSingleMergeRequestDiffVersionOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall) DoAndReturn(f func(any, int64, int64, *gitlab.GetSingleMergeRequestDiffVersionOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetSingleMergeRequestDiffVersionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTimeSpent mocks base method.
func (m *MockMergeRequestsServiceInterface) GetTimeSpent(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTimeSpent", varargs...)
	ret0, _ := ret[0].(*gitlab.TimeStats)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetTimeSpent indicates an expected call of GetTimeSpent.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) GetTimeSpent(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceGetTimeSpentCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeSpent", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).GetTimeSpent), varargs...)
	return &MockMergeRequestsServiceInterfaceGetTimeSpentCall{Call: call}
}

// MockMergeRequestsServiceInterfaceGetTimeSpentCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceGetTimeSpentCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceGetTimeSpentCall) Return(arg0 *gitlab.TimeStats, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceGetTimeSpentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceGetTimeSpentCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetTimeSpentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceGetTimeSpentCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceGetTimeSpentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListGroupMergeRequests mocks base method.
func (m *MockMergeRequestsServiceInterface) ListGroupMergeRequests(gid any, opt *gitlab.ListGroupMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{gid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupMergeRequests", varargs...)
	ret0, _ := ret[0].([]*gitlab.BasicMergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListGroupMergeRequests indicates an expected call of ListGroupMergeRequests.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ListGroupMergeRequests(gid, opt any, options ...any) *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupMergeRequests", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ListGroupMergeRequests), varargs...)
	return &MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall) Return(arg0 []*gitlab.BasicMergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall) Do(f func(any, *gitlab.ListGroupMergeRequestsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall) DoAndReturn(f func(any, *gitlab.ListGroupMergeRequestsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListGroupMergeRequestsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListMergeRequestDiffs mocks base method.
func (m *MockMergeRequestsServiceInterface) ListMergeRequestDiffs(pid any, mergeRequest int64, opt *gitlab.ListMergeRequestDiffsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiff, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMergeRequestDiffs", varargs...)
	ret0, _ := ret[0].([]*gitlab.MergeRequestDiff)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListMergeRequestDiffs indicates an expected call of ListMergeRequestDiffs.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ListMergeRequestDiffs(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestDiffs", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ListMergeRequestDiffs), varargs...)
	return &MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall) Return(arg0 []*gitlab.MergeRequestDiff, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall) Do(f func(any, int64, *gitlab.ListMergeRequestDiffsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiff, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall) DoAndReturn(f func(any, int64, *gitlab.ListMergeRequestDiffsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiff, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListMergeRequestDiffsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListMergeRequestPipelines mocks base method.
func (m *MockMergeRequestsServiceInterface) ListMergeRequestPipelines(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMergeRequestPipelines", varargs...)
	ret0, _ := ret[0].([]*gitlab.PipelineInfo)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListMergeRequestPipelines indicates an expected call of ListMergeRequestPipelines.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ListMergeRequestPipelines(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestPipelines", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ListMergeRequestPipelines), varargs...)
	return &MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall{Call: call}
}

// MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall) Return(arg0 []*gitlab.PipelineInfo, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListMergeRequestPipelinesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListMergeRequests mocks base method.
func (m *MockMergeRequestsServiceInterface) ListMergeRequests(opt *gitlab.ListMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMergeRequests", varargs...)
	ret0, _ := ret[0].([]*gitlab.BasicMergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListMergeRequests indicates an expected call of ListMergeRequests.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ListMergeRequests(opt any, options ...any) *MockMergeRequestsServiceInterfaceListMergeRequestsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequests", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ListMergeRequests), varargs...)
	return &MockMergeRequestsServiceInterfaceListMergeRequestsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceListMergeRequestsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceListMergeRequestsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceListMergeRequestsCall) Return(arg0 []*gitlab.BasicMergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceListMergeRequestsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceListMergeRequestsCall) Do(f func(*gitlab.ListMergeRequestsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListMergeRequestsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceListMergeRequestsCall) DoAndReturn(f func(*gitlab.ListMergeRequestsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListMergeRequestsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListProjectMergeRequests mocks base method.
func (m *MockMergeRequestsServiceInterface) ListProjectMergeRequests(pid any, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProjectMergeRequests", varargs...)
	ret0, _ := ret[0].([]*gitlab.BasicMergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListProjectMergeRequests indicates an expected call of ListProjectMergeRequests.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ListProjectMergeRequests(pid, opt any, options ...any) *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectMergeRequests", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ListProjectMergeRequests), varargs...)
	return &MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall) Return(arg0 []*gitlab.BasicMergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall) Do(f func(any, *gitlab.ListProjectMergeRequestsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall) DoAndReturn(f func(any, *gitlab.ListProjectMergeRequestsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListProjectMergeRequestsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListRelatedIssues mocks base method.
func (m *MockMergeRequestsServiceInterface) ListRelatedIssues(pid any, mergeRequest int64, opt *gitlab.ListRelatedIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRelatedIssues", varargs...)
	ret0, _ := ret[0].([]*gitlab.Issue)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListRelatedIssues indicates an expected call of ListRelatedIssues.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ListRelatedIssues(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceListRelatedIssuesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRelatedIssues", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ListRelatedIssues), varargs...)
	return &MockMergeRequestsServiceInterfaceListRelatedIssuesCall{Call: call}
}

// MockMergeRequestsServiceInterfaceListRelatedIssuesCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceListRelatedIssuesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceListRelatedIssuesCall) Return(arg0 []*gitlab.Issue, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceListRelatedIssuesCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceListRelatedIssuesCall) Do(f func(any, int64, *gitlab.ListRelatedIssuesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListRelatedIssuesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceListRelatedIssuesCall) DoAndReturn(f func(any, int64, *gitlab.ListRelatedIssuesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceListRelatedIssuesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RebaseMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) RebaseMergeRequest(pid any, mergeRequest int64, opt *gitlab.RebaseMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RebaseMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebaseMergeRequest indicates an expected call of RebaseMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) RebaseMergeRequest(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebaseMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).RebaseMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceRebaseMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceRebaseMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceRebaseMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall) Return(arg0 *gitlab.Response, arg1 error) *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall) Do(f func(any, int64, *gitlab.RebaseMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall) DoAndReturn(f func(any, int64, *gitlab.RebaseMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockMergeRequestsServiceInterfaceRebaseMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetSpentTime mocks base method.
func (m *MockMergeRequestsServiceInterface) ResetSpentTime(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetSpentTime", varargs...)
	ret0, _ := ret[0].(*gitlab.TimeStats)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResetSpentTime indicates an expected call of ResetSpentTime.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ResetSpentTime(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceResetSpentTimeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSpentTime", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ResetSpentTime), varargs...)
	return &MockMergeRequestsServiceInterfaceResetSpentTimeCall{Call: call}
}

// MockMergeRequestsServiceInterfaceResetSpentTimeCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceResetSpentTimeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceResetSpentTimeCall) Return(arg0 *gitlab.TimeStats, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceResetSpentTimeCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceResetSpentTimeCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceResetSpentTimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceResetSpentTimeCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceResetSpentTimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetTimeEstimate mocks base method.
func (m *MockMergeRequestsServiceInterface) ResetTimeEstimate(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetTimeEstimate", varargs...)
	ret0, _ := ret[0].(*gitlab.TimeStats)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResetTimeEstimate indicates an expected call of ResetTimeEstimate.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ResetTimeEstimate(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceResetTimeEstimateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetTimeEstimate", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ResetTimeEstimate), varargs...)
	return &MockMergeRequestsServiceInterfaceResetTimeEstimateCall{Call: call}
}

// MockMergeRequestsServiceInterfaceResetTimeEstimateCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceResetTimeEstimateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceResetTimeEstimateCall) Return(arg0 *gitlab.TimeStats, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceResetTimeEstimateCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceResetTimeEstimateCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceResetTimeEstimateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceResetTimeEstimateCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceResetTimeEstimateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetTimeEstimate mocks base method.
func (m *MockMergeRequestsServiceInterface) SetTimeEstimate(pid any, mergeRequest int64, opt *gitlab.SetTimeEstimateOptions, options ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetTimeEstimate", varargs...)
	ret0, _ := ret[0].(*gitlab.TimeStats)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SetTimeEstimate indicates an expected call of SetTimeEstimate.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) SetTimeEstimate(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceSetTimeEstimateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeEstimate", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).SetTimeEstimate), varargs...)
	return &MockMergeRequestsServiceInterfaceSetTimeEstimateCall{Call: call}
}

// MockMergeRequestsServiceInterfaceSetTimeEstimateCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceSetTimeEstimateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceSetTimeEstimateCall) Return(arg0 *gitlab.TimeStats, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceSetTimeEstimateCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceSetTimeEstimateCall) Do(f func(any, int64, *gitlab.SetTimeEstimateOptions, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceSetTimeEstimateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceSetTimeEstimateCall) DoAndReturn(f func(any, int64, *gitlab.SetTimeEstimateOptions, ...gitlab.RequestOptionFunc) (*gitlab.TimeStats, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceSetTimeEstimateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ShowMergeRequestRawDiffs mocks base method.
func (m *MockMergeRequestsServiceInterface) ShowMergeRequestRawDiffs(pid any, mergeRequest int64, opt *gitlab.ShowMergeRequestRawDiffsOptions, options ...gitlab.RequestOptionFunc) ([]byte, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShowMergeRequestRawDiffs", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ShowMergeRequestRawDiffs indicates an expected call of ShowMergeRequestRawDiffs.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) ShowMergeRequestRawDiffs(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShowMergeRequestRawDiffs", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).ShowMergeRequestRawDiffs), varargs...)
	return &MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall{Call: call}
}

// MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall) Return(arg0 []byte, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall) Do(f func(any, int64, *gitlab.ShowMergeRequestRawDiffsOptions, ...gitlab.RequestOptionFunc) ([]byte, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall) DoAndReturn(f func(any, int64, *gitlab.ShowMergeRequestRawDiffsOptions, ...gitlab.RequestOptionFunc) ([]byte, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceShowMergeRequestRawDiffsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SubscribeToMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) SubscribeToMergeRequest(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeToMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SubscribeToMergeRequest indicates an expected call of SubscribeToMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) SubscribeToMergeRequest(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeToMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).SubscribeToMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceSubscribeToMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnsubscribeFromMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) UnsubscribeFromMergeRequest(pid any, mergeRequest int64, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnsubscribeFromMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UnsubscribeFromMergeRequest indicates an expected call of UnsubscribeFromMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) UnsubscribeFromMergeRequest(pid, mergeRequest any, options ...any) *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeFromMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).UnsubscribeFromMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall) Do(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall) DoAndReturn(f func(any, int64, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceUnsubscribeFromMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateMergeRequest mocks base method.
func (m *MockMergeRequestsServiceInterface) UpdateMergeRequest(pid any, mergeRequest int64, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMergeRequest", varargs...)
	ret0, _ := ret[0].(*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateMergeRequest indicates an expected call of UpdateMergeRequest.
func (mr *MockMergeRequestsServiceInterfaceMockRecorder) UpdateMergeRequest(pid, mergeRequest, opt any, options ...any) *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMergeRequest", reflect.TypeOf((*MockMergeRequestsServiceInterface)(nil).UpdateMergeRequest), varargs...)
	return &MockMergeRequestsServiceInterfaceUpdateMergeRequestCall{Call: call}
}

// MockMergeRequestsServiceInterfaceUpdateMergeRequestCall wrap *gomock.Call
type MockMergeRequestsServiceInterfaceUpdateMergeRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall) Return(arg0 *gitlab.MergeRequest, arg1 *gitlab.Response, arg2 error) *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall) Do(f func(any, int64, *gitlab.UpdateMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall) DoAndReturn(f func(any, int64, *gitlab.UpdateMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)) *MockMergeRequestsServiceInterfaceUpdateMergeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}