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

package testing

import (
	reflect "reflect"

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

// MockDiscussionsServiceInterface is a mock of DiscussionsServiceInterface interface.
type MockDiscussionsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockDiscussionsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockDiscussionsServiceInterfaceMockRecorder is the mock recorder for MockDiscussionsServiceInterface.
type MockDiscussionsServiceInterfaceMockRecorder struct {
	mock *MockDiscussionsServiceInterface
}

// NewMockDiscussionsServiceInterface creates a new mock instance.
func NewMockDiscussionsServiceInterface(ctrl *gomock.Controller) *MockDiscussionsServiceInterface {
	mock := &MockDiscussionsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockDiscussionsServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// AddCommitDiscussionNote indicates an expected call of AddCommitDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) AddCommitDiscussionNote(pid, commit, discussion, opt any, options ...any) *MockDiscussionsServiceInterfaceAddCommitDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, commit, discussion, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCommitDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).AddCommitDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceAddCommitDiscussionNoteCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDiscussionsServiceInterfaceAddCommitDiscussionNoteCall) Do(f func(any, string, string, *gitlab.AddCommitDiscussionNoteOptions, ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)) *MockDiscussionsServiceInterfaceAddCommitDiscussionNoteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDiscussionsServiceInterfaceAddCommitDiscussionNoteCall) DoAndReturn(f func(any, string, string, *gitlab.AddCommitDiscussionNoteOptions, ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)) *MockDiscussionsServiceInterfaceAddCommitDiscussionNoteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddEpicDiscussionNote mocks base method.
func (m *MockDiscussionsServiceInterface) AddEpicDiscussionNote(gid any, epic int64, discussion string, opt *gitlab.AddEpicDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{gid, epic, discussion, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddEpicDiscussionNote", varargs...)
	ret0, _ := ret[0].(*gitlab.Note)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddEpicDiscussionNote indicates an expected call of AddEpicDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) AddEpicDiscussionNote(gid, epic, discussion, opt any, options ...any) *MockDiscussionsServiceInterfaceAddEpicDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, epic, discussion, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEpicDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).AddEpicDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceAddEpicDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// AddIssueDiscussionNote indicates an expected call of AddIssueDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) AddIssueDiscussionNote(pid, issue, discussion, opt any, options ...any) *MockDiscussionsServiceInterfaceAddIssueDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issue, discussion, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIssueDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).AddIssueDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceAddIssueDiscussionNoteCall{Call: call}
}

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

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

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

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

// AddMergeRequestDiscussionNote mocks base method.
func (m *MockDiscussionsServiceInterface) AddMergeRequestDiscussionNote(pid any, mergeRequest int64, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, 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 *MockDiscussionsServiceInterfaceMockRecorder) AddMergeRequestDiscussionNote(pid, mergeRequest, discussion, opt any, options ...any) *MockDiscussionsServiceInterfaceAddMergeRequestDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, discussion, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMergeRequestDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).AddMergeRequestDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceAddMergeRequestDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// AddSnippetDiscussionNote indicates an expected call of AddSnippetDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) AddSnippetDiscussionNote(pid, snippet, discussion, opt any, options ...any) *MockDiscussionsServiceInterfaceAddSnippetDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippet, discussion, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSnippetDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).AddSnippetDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceAddSnippetDiscussionNoteCall{Call: call}
}

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDiscussionsServiceInterfaceCreateCommitDiscussionCall) Do(f func(any, string, *gitlab.CreateCommitDiscussionOptions, ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)) *MockDiscussionsServiceInterfaceCreateCommitDiscussionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDiscussionsServiceInterfaceCreateCommitDiscussionCall) DoAndReturn(f func(any, string, *gitlab.CreateCommitDiscussionOptions, ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)) *MockDiscussionsServiceInterfaceCreateCommitDiscussionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

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

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

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

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

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

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

// CreateMergeRequestDiscussion mocks base method.
func (m *MockDiscussionsServiceInterface) CreateMergeRequestDiscussion(pid any, mergeRequest int64, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *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, "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 *MockDiscussionsServiceInterfaceMockRecorder) CreateMergeRequestDiscussion(pid, mergeRequest, opt any, options ...any) *MockDiscussionsServiceInterfaceCreateMergeRequestDiscussionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestDiscussion", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).CreateMergeRequestDiscussion), varargs...)
	return &MockDiscussionsServiceInterfaceCreateMergeRequestDiscussionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// DeleteCommitDiscussionNote indicates an expected call of DeleteCommitDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) DeleteCommitDiscussionNote(pid, commit, discussion, note any, options ...any) *MockDiscussionsServiceInterfaceDeleteCommitDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, commit, discussion, note}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCommitDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).DeleteCommitDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceDeleteCommitDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// DeleteEpicDiscussionNote indicates an expected call of DeleteEpicDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) DeleteEpicDiscussionNote(gid, epic, discussion, note any, options ...any) *MockDiscussionsServiceInterfaceDeleteEpicDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, epic, discussion, note}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEpicDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).DeleteEpicDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceDeleteEpicDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// DeleteIssueDiscussionNote indicates an expected call of DeleteIssueDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) DeleteIssueDiscussionNote(pid, issue, discussion, note any, options ...any) *MockDiscussionsServiceInterfaceDeleteIssueDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issue, discussion, note}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIssueDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).DeleteIssueDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceDeleteIssueDiscussionNoteCall{Call: call}
}

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

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

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

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

// DeleteMergeRequestDiscussionNote mocks base method.
func (m *MockDiscussionsServiceInterface) DeleteMergeRequestDiscussionNote(pid any, mergeRequest int64, discussion string, note int64, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, 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 *MockDiscussionsServiceInterfaceMockRecorder) DeleteMergeRequestDiscussionNote(pid, mergeRequest, discussion, note any, options ...any) *MockDiscussionsServiceInterfaceDeleteMergeRequestDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, discussion, note}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).DeleteMergeRequestDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceDeleteMergeRequestDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// DeleteSnippetDiscussionNote indicates an expected call of DeleteSnippetDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) DeleteSnippetDiscussionNote(pid, snippet, discussion, note any, options ...any) *MockDiscussionsServiceInterfaceDeleteSnippetDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippet, discussion, note}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnippetDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).DeleteSnippetDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceDeleteSnippetDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// GetCommitDiscussion indicates an expected call of GetCommitDiscussion.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) GetCommitDiscussion(pid, commit, discussion any, options ...any) *MockDiscussionsServiceInterfaceGetCommitDiscussionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, commit, discussion}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitDiscussion", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).GetCommitDiscussion), varargs...)
	return &MockDiscussionsServiceInterfaceGetCommitDiscussionCall{Call: call}
}

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

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

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

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

// GetEpicDiscussion mocks base method.
func (m *MockDiscussionsServiceInterface) GetEpicDiscussion(gid any, epic int64, discussion string, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{gid, epic, discussion}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEpicDiscussion", varargs...)
	ret0, _ := ret[0].(*gitlab.Discussion)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetEpicDiscussion indicates an expected call of GetEpicDiscussion.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) GetEpicDiscussion(gid, epic, discussion any, options ...any) *MockDiscussionsServiceInterfaceGetEpicDiscussionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, epic, discussion}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpicDiscussion", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).GetEpicDiscussion), varargs...)
	return &MockDiscussionsServiceInterfaceGetEpicDiscussionCall{Call: call}
}

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

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

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

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

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

// GetIssueDiscussion indicates an expected call of GetIssueDiscussion.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) GetIssueDiscussion(pid, issue, discussion any, options ...any) *MockDiscussionsServiceInterfaceGetIssueDiscussionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issue, discussion}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueDiscussion", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).GetIssueDiscussion), varargs...)
	return &MockDiscussionsServiceInterfaceGetIssueDiscussionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// GetSnippetDiscussion indicates an expected call of GetSnippetDiscussion.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) GetSnippetDiscussion(pid, snippet, discussion any, options ...any) *MockDiscussionsServiceInterfaceGetSnippetDiscussionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippet, discussion}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnippetDiscussion", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).GetSnippetDiscussion), varargs...)
	return &MockDiscussionsServiceInterfaceGetSnippetDiscussionCall{Call: call}
}

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDiscussionsServiceInterfaceListCommitDiscussionsCall) Do(f func(any, string, *gitlab.ListCommitDiscussionsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error)) *MockDiscussionsServiceInterfaceListCommitDiscussionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDiscussionsServiceInterfaceListCommitDiscussionsCall) DoAndReturn(f func(any, string, *gitlab.ListCommitDiscussionsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error)) *MockDiscussionsServiceInterfaceListCommitDiscussionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

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

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

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

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

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

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

// ListMergeRequestDiscussions mocks base method.
func (m *MockDiscussionsServiceInterface) ListMergeRequestDiscussions(pid any, mergeRequest int64, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *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, "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 *MockDiscussionsServiceInterfaceMockRecorder) ListMergeRequestDiscussions(pid, mergeRequest, opt any, options ...any) *MockDiscussionsServiceInterfaceListMergeRequestDiscussionsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestDiscussions", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).ListMergeRequestDiscussions), varargs...)
	return &MockDiscussionsServiceInterfaceListMergeRequestDiscussionsCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// ResolveMergeRequestDiscussion mocks base method.
func (m *MockDiscussionsServiceInterface) ResolveMergeRequestDiscussion(pid any, mergeRequest int64, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, 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 *MockDiscussionsServiceInterfaceMockRecorder) ResolveMergeRequestDiscussion(pid, mergeRequest, discussion, opt any, options ...any) *MockDiscussionsServiceInterfaceResolveMergeRequestDiscussionCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, discussion, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveMergeRequestDiscussion", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).ResolveMergeRequestDiscussion), varargs...)
	return &MockDiscussionsServiceInterfaceResolveMergeRequestDiscussionCall{Call: call}
}

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

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

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

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

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

// UpdateCommitDiscussionNote indicates an expected call of UpdateCommitDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) UpdateCommitDiscussionNote(pid, commit, discussion, note, opt any, options ...any) *MockDiscussionsServiceInterfaceUpdateCommitDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, commit, discussion, note, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommitDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).UpdateCommitDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceUpdateCommitDiscussionNoteCall{Call: call}
}

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

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

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

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

// UpdateEpicDiscussionNote mocks base method.
func (m *MockDiscussionsServiceInterface) UpdateEpicDiscussionNote(gid any, epic int64, discussion string, note int64, opt *gitlab.UpdateEpicDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{gid, epic, discussion, note, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateEpicDiscussionNote", varargs...)
	ret0, _ := ret[0].(*gitlab.Note)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateEpicDiscussionNote indicates an expected call of UpdateEpicDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) UpdateEpicDiscussionNote(gid, epic, discussion, note, opt any, options ...any) *MockDiscussionsServiceInterfaceUpdateEpicDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, epic, discussion, note, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEpicDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).UpdateEpicDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceUpdateEpicDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// UpdateIssueDiscussionNote indicates an expected call of UpdateIssueDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) UpdateIssueDiscussionNote(pid, issue, discussion, note, opt any, options ...any) *MockDiscussionsServiceInterfaceUpdateIssueDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issue, discussion, note, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIssueDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).UpdateIssueDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceUpdateIssueDiscussionNoteCall{Call: call}
}

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

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

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

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

// UpdateMergeRequestDiscussionNote mocks base method.
func (m *MockDiscussionsServiceInterface) UpdateMergeRequestDiscussionNote(pid any, mergeRequest int64, discussion string, note int64, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, mergeRequest, 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 *MockDiscussionsServiceInterfaceMockRecorder) UpdateMergeRequestDiscussionNote(pid, mergeRequest, discussion, note, opt any, options ...any) *MockDiscussionsServiceInterfaceUpdateMergeRequestDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequest, discussion, note, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMergeRequestDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).UpdateMergeRequestDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceUpdateMergeRequestDiscussionNoteCall{Call: call}
}

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

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

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

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

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

// UpdateSnippetDiscussionNote indicates an expected call of UpdateSnippetDiscussionNote.
func (mr *MockDiscussionsServiceInterfaceMockRecorder) UpdateSnippetDiscussionNote(pid, snippet, discussion, note, opt any, options ...any) *MockDiscussionsServiceInterfaceUpdateSnippetDiscussionNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippet, discussion, note, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSnippetDiscussionNote", reflect.TypeOf((*MockDiscussionsServiceInterface)(nil).UpdateSnippetDiscussionNote), varargs...)
	return &MockDiscussionsServiceInterfaceUpdateSnippetDiscussionNoteCall{Call: call}
}

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

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

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

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