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

package testing

import (
	reflect "reflect"

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

// MockAwardEmojiServiceInterface is a mock of AwardEmojiServiceInterface interface.
type MockAwardEmojiServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockAwardEmojiServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockAwardEmojiServiceInterfaceMockRecorder is the mock recorder for MockAwardEmojiServiceInterface.
type MockAwardEmojiServiceInterfaceMockRecorder struct {
	mock *MockAwardEmojiServiceInterface
}

// NewMockAwardEmojiServiceInterface creates a new mock instance.
func NewMockAwardEmojiServiceInterface(ctrl *gomock.Controller) *MockAwardEmojiServiceInterface {
	mock := &MockAwardEmojiServiceInterface{ctrl: ctrl}
	mock.recorder = &MockAwardEmojiServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

// CreateIssuesAwardEmojiOnNote indicates an expected call of CreateIssuesAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) CreateIssuesAwardEmojiOnNote(pid, issueID, noteID, opt any, options ...any) *MockAwardEmojiServiceInterfaceCreateIssuesAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issueID, noteID, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIssuesAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).CreateIssuesAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceCreateIssuesAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

// CreateMergeRequestAwardEmoji mocks base method.
func (m *MockAwardEmojiServiceInterface) CreateMergeRequestAwardEmoji(pid any, mergeRequestIID int64, opt *gitlab.CreateAwardEmojiOptions, options ...gitlab.RequestOptionFunc) (*gitlab.AwardEmoji, *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, "CreateMergeRequestAwardEmoji", varargs...)
	ret0, _ := ret[0].(*gitlab.AwardEmoji)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

// CreateMergeRequestAwardEmojiOnNote mocks base method.
func (m *MockAwardEmojiServiceInterface) CreateMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID int64, 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 *MockAwardEmojiServiceInterfaceMockRecorder) CreateMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt any, options ...any) *MockAwardEmojiServiceInterfaceCreateMergeRequestAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, noteID, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).CreateMergeRequestAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceCreateMergeRequestAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// CreateSnippetAwardEmojiOnNote indicates an expected call of CreateSnippetAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) CreateSnippetAwardEmojiOnNote(pid, snippetIID, noteID, opt any, options ...any) *MockAwardEmojiServiceInterfaceCreateSnippetAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippetIID, noteID, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnippetAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).CreateSnippetAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceCreateSnippetAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

// DeleteIssueAwardEmoji indicates an expected call of DeleteIssueAwardEmoji.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) DeleteIssueAwardEmoji(pid, issueIID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceDeleteIssueAwardEmojiCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issueIID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIssueAwardEmoji", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).DeleteIssueAwardEmoji), varargs...)
	return &MockAwardEmojiServiceInterfaceDeleteIssueAwardEmojiCall{Call: call}
}

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

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

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

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

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

// DeleteIssuesAwardEmojiOnNote indicates an expected call of DeleteIssuesAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) DeleteIssuesAwardEmojiOnNote(pid, issueID, noteID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceDeleteIssuesAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issueID, noteID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIssuesAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).DeleteIssuesAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceDeleteIssuesAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

// DeleteMergeRequestAwardEmoji indicates an expected call of DeleteMergeRequestAwardEmoji.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) DeleteMergeRequestAwardEmoji(pid, mergeRequestIID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceDeleteMergeRequestAwardEmojiCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestAwardEmoji", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).DeleteMergeRequestAwardEmoji), varargs...)
	return &MockAwardEmojiServiceInterfaceDeleteMergeRequestAwardEmojiCall{Call: call}
}

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

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

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

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

// DeleteMergeRequestAwardEmojiOnNote mocks base method.
func (m *MockAwardEmojiServiceInterface) DeleteMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID, awardID int64, 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 *MockAwardEmojiServiceInterfaceMockRecorder) DeleteMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceDeleteMergeRequestAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, noteID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).DeleteMergeRequestAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceDeleteMergeRequestAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

// DeleteSnippetAwardEmoji indicates an expected call of DeleteSnippetAwardEmoji.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) DeleteSnippetAwardEmoji(pid, snippetID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceDeleteSnippetAwardEmojiCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippetID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnippetAwardEmoji", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).DeleteSnippetAwardEmoji), varargs...)
	return &MockAwardEmojiServiceInterfaceDeleteSnippetAwardEmojiCall{Call: call}
}

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

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

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

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

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

// DeleteSnippetAwardEmojiOnNote indicates an expected call of DeleteSnippetAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) DeleteSnippetAwardEmojiOnNote(pid, snippetIID, noteID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceDeleteSnippetAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippetIID, noteID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnippetAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).DeleteSnippetAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceDeleteSnippetAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

// GetIssueAwardEmoji indicates an expected call of GetIssueAwardEmoji.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) GetIssueAwardEmoji(pid, issueIID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceGetIssueAwardEmojiCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issueIID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueAwardEmoji", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).GetIssueAwardEmoji), varargs...)
	return &MockAwardEmojiServiceInterfaceGetIssueAwardEmojiCall{Call: call}
}

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

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

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

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

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

// GetIssuesAwardEmojiOnNote indicates an expected call of GetIssuesAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) GetIssuesAwardEmojiOnNote(pid, issueID, noteID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceGetIssuesAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issueID, noteID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssuesAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).GetIssuesAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceGetIssuesAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

// GetMergeRequestAwardEmoji indicates an expected call of GetMergeRequestAwardEmoji.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) GetMergeRequestAwardEmoji(pid, mergeRequestIID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceGetMergeRequestAwardEmojiCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestAwardEmoji", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).GetMergeRequestAwardEmoji), varargs...)
	return &MockAwardEmojiServiceInterfaceGetMergeRequestAwardEmojiCall{Call: call}
}

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

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

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

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

// GetMergeRequestAwardEmojiOnNote mocks base method.
func (m *MockAwardEmojiServiceInterface) GetMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID, awardID int64, options ...gitlab.RequestOptionFunc) (*gitlab.AwardEmoji, *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, "GetMergeRequestAwardEmojiOnNote", varargs...)
	ret0, _ := ret[0].(*gitlab.AwardEmoji)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

// GetSnippetAwardEmoji indicates an expected call of GetSnippetAwardEmoji.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) GetSnippetAwardEmoji(pid, snippetID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceGetSnippetAwardEmojiCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippetID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnippetAwardEmoji", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).GetSnippetAwardEmoji), varargs...)
	return &MockAwardEmojiServiceInterfaceGetSnippetAwardEmojiCall{Call: call}
}

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

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

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

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

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

// GetSnippetAwardEmojiOnNote indicates an expected call of GetSnippetAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) GetSnippetAwardEmojiOnNote(pid, snippetIID, noteID, awardID any, options ...any) *MockAwardEmojiServiceInterfaceGetSnippetAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippetIID, noteID, awardID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnippetAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).GetSnippetAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceGetSnippetAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// ListIssuesAwardEmojiOnNote indicates an expected call of ListIssuesAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) ListIssuesAwardEmojiOnNote(pid, issueID, noteID, opt any, options ...any) *MockAwardEmojiServiceInterfaceListIssuesAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issueID, noteID, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIssuesAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).ListIssuesAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceListIssuesAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

// ListMergeRequestAwardEmoji mocks base method.
func (m *MockAwardEmojiServiceInterface) ListMergeRequestAwardEmoji(pid any, mergeRequestIID int64, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *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, "ListMergeRequestAwardEmoji", varargs...)
	ret0, _ := ret[0].([]*gitlab.AwardEmoji)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

// ListMergeRequestAwardEmojiOnNote mocks base method.
func (m *MockAwardEmojiServiceInterface) ListMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID int64, 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 *MockAwardEmojiServiceInterfaceMockRecorder) ListMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt any, options ...any) *MockAwardEmojiServiceInterfaceListMergeRequestAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, mergeRequestIID, noteID, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).ListMergeRequestAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceListMergeRequestAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// ListSnippetAwardEmojiOnNote indicates an expected call of ListSnippetAwardEmojiOnNote.
func (mr *MockAwardEmojiServiceInterfaceMockRecorder) ListSnippetAwardEmojiOnNote(pid, snippetIID, noteID, opt any, options ...any) *MockAwardEmojiServiceInterfaceListSnippetAwardEmojiOnNoteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, snippetIID, noteID, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnippetAwardEmojiOnNote", reflect.TypeOf((*MockAwardEmojiServiceInterface)(nil).ListSnippetAwardEmojiOnNote), varargs...)
	return &MockAwardEmojiServiceInterfaceListSnippetAwardEmojiOnNoteCall{Call: call}
}

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

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

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

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