// Code generated by MockGen. DO NOT EDIT.
// Source: cmd/types.go
//
// Generated by this command:
//
//	mockgen -source cmd/types.go
//

// Package mock_main is a generated GoMock package.
package mock_main

import (
	bytes "bytes"
	io "io"
	reflect "reflect"

	gitlab "github.com/xanzy/go-gitlab"
	gomock "go.uber.org/mock/gomock"
)

// MockClientInterface is a mock of ClientInterface interface.
type MockClientInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientInterfaceMockRecorder
}

// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
type MockClientInterfaceMockRecorder struct {
	mock *MockClientInterface
}

// NewMockClientInterface creates a new mock instance.
func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
	mock := &MockClientInterface{ctrl: ctrl}
	mock.recorder = &MockClientInterfaceMockRecorder{mock}
	return mock
}

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

// AcceptMergeRequest mocks base method.
func (m *MockClientInterface) AcceptMergeRequest(pid any, mergeRequestIID int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, 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 *MockClientInterfaceMockRecorder) AcceptMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).AcceptMergeRequest), varargs...)
}

// AddMergeRequestDiscussionNote mocks base method.
func (m *MockClientInterface) AddMergeRequestDiscussionNote(pid any, mergeRequestIID int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, discussion, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddMergeRequestDiscussionNote", varargs...)
	ret0, _ := ret[0].(*gitlab.Note)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddMergeRequestDiscussionNote indicates an expected call of AddMergeRequestDiscussionNote.
func (mr *MockClientInterfaceMockRecorder) AddMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, discussion, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMergeRequestDiscussionNote", reflect.TypeOf((*MockClientInterface)(nil).AddMergeRequestDiscussionNote), varargs...)
}

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

// ApproveMergeRequest indicates an expected call of ApproveMergeRequest.
func (mr *MockClientInterfaceMockRecorder) ApproveMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).ApproveMergeRequest), varargs...)
}

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

// CreateDraftNote indicates an expected call of CreateDraftNote.
func (mr *MockClientInterfaceMockRecorder) CreateDraftNote(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftNote", reflect.TypeOf((*MockClientInterface)(nil).CreateDraftNote), varargs...)
}

// CreateMergeRequest mocks base method.
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) CreateMergeRequest(pid, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).CreateMergeRequest), varargs...)
}

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

// CreateMergeRequestAwardEmojiOnNote indicates an expected call of CreateMergeRequestAwardEmojiOnNote.
func (mr *MockClientInterfaceMockRecorder) CreateMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, noteID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockClientInterface)(nil).CreateMergeRequestAwardEmojiOnNote), varargs...)
}

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

// CreateMergeRequestDiscussion indicates an expected call of CreateMergeRequestDiscussion.
func (mr *MockClientInterfaceMockRecorder) CreateMergeRequestDiscussion(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestDiscussion", reflect.TypeOf((*MockClientInterface)(nil).CreateMergeRequestDiscussion), varargs...)
}

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

// CurrentUser indicates an expected call of CurrentUser.
func (mr *MockClientInterfaceMockRecorder) CurrentUser(options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentUser", reflect.TypeOf((*MockClientInterface)(nil).CurrentUser), options...)
}

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

// DeleteDraftNote indicates an expected call of DeleteDraftNote.
func (mr *MockClientInterfaceMockRecorder) DeleteDraftNote(pid, mergeRequest, note any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, note}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftNote", reflect.TypeOf((*MockClientInterface)(nil).DeleteDraftNote), varargs...)
}

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

// DeleteMergeRequestAwardEmojiOnNote indicates an expected call of DeleteMergeRequestAwardEmojiOnNote.
func (mr *MockClientInterfaceMockRecorder) DeleteMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, awardID any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, noteID, awardID}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockClientInterface)(nil).DeleteMergeRequestAwardEmojiOnNote), varargs...)
}

// DeleteMergeRequestDiscussionNote mocks base method.
func (m *MockClientInterface) DeleteMergeRequestDiscussionNote(pid any, mergeRequestIID int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, discussion, note}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMergeRequestDiscussionNote", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMergeRequestDiscussionNote indicates an expected call of DeleteMergeRequestDiscussionNote.
func (mr *MockClientInterfaceMockRecorder) DeleteMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, note any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, discussion, note}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestDiscussionNote", reflect.TypeOf((*MockClientInterface)(nil).DeleteMergeRequestDiscussionNote), varargs...)
}

// GetMergeRequest mocks base method.
func (m *MockClientInterface) GetMergeRequest(pid any, mergeRequestIID int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, 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 *MockClientInterfaceMockRecorder) GetMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).GetMergeRequest), varargs...)
}

// GetMergeRequestDiffVersions mocks base method.
func (m *MockClientInterface) GetMergeRequestDiffVersions(pid any, mergeRequestIID int, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, 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 *MockClientInterfaceMockRecorder) GetMergeRequestDiffVersions(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestDiffVersions", reflect.TypeOf((*MockClientInterface)(nil).GetMergeRequestDiffVersions), varargs...)
}

// GetTraceFile mocks base method.
func (m *MockClientInterface) GetTraceFile(pid any, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, jobID}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTraceFile", varargs...)
	ret0, _ := ret[0].(*bytes.Reader)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetTraceFile indicates an expected call of GetTraceFile.
func (mr *MockClientInterfaceMockRecorder) GetTraceFile(pid, jobID any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, jobID}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTraceFile", reflect.TypeOf((*MockClientInterface)(nil).GetTraceFile), varargs...)
}

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

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

// ListDraftNotes mocks base method.
func (m *MockClientInterface) ListDraftNotes(pid any, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *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, "ListDraftNotes", varargs...)
	ret0, _ := ret[0].([]*gitlab.DraftNote)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

// ListMergeRequestAwardEmojiOnNote indicates an expected call of ListMergeRequestAwardEmojiOnNote.
func (mr *MockClientInterfaceMockRecorder) ListMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, noteID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockClientInterface)(nil).ListMergeRequestAwardEmojiOnNote), varargs...)
}

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

// ListMergeRequestDiscussions indicates an expected call of ListMergeRequestDiscussions.
func (mr *MockClientInterfaceMockRecorder) ListMergeRequestDiscussions(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestDiscussions", reflect.TypeOf((*MockClientInterface)(nil).ListMergeRequestDiscussions), varargs...)
}

// ListPipelineJobs mocks base method.
func (m *MockClientInterface) ListPipelineJobs(pid any, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, pipelineID, opts}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPipelineJobs", varargs...)
	ret0, _ := ret[0].([]*gitlab.Job)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListPipelineJobs indicates an expected call of ListPipelineJobs.
func (mr *MockClientInterfaceMockRecorder) ListPipelineJobs(pid, pipelineID, opts any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, pipelineID, opts}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineJobs", reflect.TypeOf((*MockClientInterface)(nil).ListPipelineJobs), varargs...)
}

// ListProjectMergeRequests mocks base method.
func (m *MockClientInterface) ListProjectMergeRequests(pid any, opt *gitlab.ListProjectMergeRequestsOptions, 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, "ListProjectMergeRequests", varargs...)
	ret0, _ := ret[0].([]*gitlab.MergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// PublishAllDraftNotes mocks base method.
func (m *MockClientInterface) PublishAllDraftNotes(pid any, mergeRequest int, 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, "PublishAllDraftNotes", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// PublishDraftNote indicates an expected call of PublishDraftNote.
func (mr *MockClientInterfaceMockRecorder) PublishDraftNote(pid, mergeRequest, note any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, note}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishDraftNote", reflect.TypeOf((*MockClientInterface)(nil).PublishDraftNote), varargs...)
}

// ResolveMergeRequestDiscussion mocks base method.
func (m *MockClientInterface) ResolveMergeRequestDiscussion(pid any, mergeRequestIID int, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, discussion, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResolveMergeRequestDiscussion", varargs...)
	ret0, _ := ret[0].(*gitlab.Discussion)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResolveMergeRequestDiscussion indicates an expected call of ResolveMergeRequestDiscussion.
func (mr *MockClientInterfaceMockRecorder) ResolveMergeRequestDiscussion(pid, mergeRequestIID, discussion, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, discussion, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveMergeRequestDiscussion", reflect.TypeOf((*MockClientInterface)(nil).ResolveMergeRequestDiscussion), varargs...)
}

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

// RetryPipelineBuild indicates an expected call of RetryPipelineBuild.
func (mr *MockClientInterfaceMockRecorder) RetryPipelineBuild(pid, pipeline any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, pipeline}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryPipelineBuild", reflect.TypeOf((*MockClientInterface)(nil).RetryPipelineBuild), varargs...)
}

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

// UnapproveMergeRequest indicates an expected call of UnapproveMergeRequest.
func (mr *MockClientInterfaceMockRecorder) UnapproveMergeRequest(pid, mergeRequestIID any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnapproveMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).UnapproveMergeRequest), varargs...)
}

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

// UpdateDraftNote indicates an expected call of UpdateDraftNote.
func (mr *MockClientInterfaceMockRecorder) UpdateDraftNote(pid, mergeRequest, note, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, note, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftNote", reflect.TypeOf((*MockClientInterface)(nil).UpdateDraftNote), varargs...)
}

// UpdateMergeRequest mocks base method.
func (m *MockClientInterface) UpdateMergeRequest(pid any, mergeRequestIID int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, 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 *MockClientInterfaceMockRecorder) UpdateMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).UpdateMergeRequest), varargs...)
}

// UpdateMergeRequestDiscussionNote mocks base method.
func (m *MockClientInterface) UpdateMergeRequestDiscussionNote(pid any, mergeRequestIID int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequestIID, discussion, note, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMergeRequestDiscussionNote", varargs...)
	ret0, _ := ret[0].(*gitlab.Note)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateMergeRequestDiscussionNote indicates an expected call of UpdateMergeRequestDiscussionNote.
func (mr *MockClientInterfaceMockRecorder) UpdateMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, note, opt any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, discussion, note, opt}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMergeRequestDiscussionNote", reflect.TypeOf((*MockClientInterface)(nil).UpdateMergeRequestDiscussionNote), varargs...)
}

// UploadFile mocks base method.
func (m *MockClientInterface) UploadFile(pid any, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, content, filename}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadFile", varargs...)
	ret0, _ := ret[0].(*gitlab.ProjectFile)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UploadFile indicates an expected call of UploadFile.
func (mr *MockClientInterfaceMockRecorder) UploadFile(pid, content, filename any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, content, filename}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadFile", reflect.TypeOf((*MockClientInterface)(nil).UploadFile), varargs...)
}