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

package testing

import (
	reflect "reflect"

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

// MockResourceLabelEventsServiceInterface is a mock of ResourceLabelEventsServiceInterface interface.
type MockResourceLabelEventsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockResourceLabelEventsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockResourceLabelEventsServiceInterfaceMockRecorder is the mock recorder for MockResourceLabelEventsServiceInterface.
type MockResourceLabelEventsServiceInterfaceMockRecorder struct {
	mock *MockResourceLabelEventsServiceInterface
}

// NewMockResourceLabelEventsServiceInterface creates a new mock instance.
func NewMockResourceLabelEventsServiceInterface(ctrl *gomock.Controller) *MockResourceLabelEventsServiceInterface {
	mock := &MockResourceLabelEventsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockResourceLabelEventsServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// GetGroupEpicLabelEvent indicates an expected call of GetGroupEpicLabelEvent.
func (mr *MockResourceLabelEventsServiceInterfaceMockRecorder) GetGroupEpicLabelEvent(gid, epic, event any, options ...any) *MockResourceLabelEventsServiceInterfaceGetGroupEpicLabelEventCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, epic, event}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupEpicLabelEvent", reflect.TypeOf((*MockResourceLabelEventsServiceInterface)(nil).GetGroupEpicLabelEvent), varargs...)
	return &MockResourceLabelEventsServiceInterfaceGetGroupEpicLabelEventCall{Call: call}
}

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

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

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

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

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

// GetIssueLabelEvent indicates an expected call of GetIssueLabelEvent.
func (mr *MockResourceLabelEventsServiceInterfaceMockRecorder) GetIssueLabelEvent(pid, issue, event any, options ...any) *MockResourceLabelEventsServiceInterfaceGetIssueLabelEventCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, issue, event}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueLabelEvent", reflect.TypeOf((*MockResourceLabelEventsServiceInterface)(nil).GetIssueLabelEvent), varargs...)
	return &MockResourceLabelEventsServiceInterfaceGetIssueLabelEventCall{Call: call}
}

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

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

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

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

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

// GetMergeRequestLabelEvent indicates an expected call of GetMergeRequestLabelEvent.
func (mr *MockResourceLabelEventsServiceInterfaceMockRecorder) GetMergeRequestLabelEvent(pid, request, event any, options ...any) *MockResourceLabelEventsServiceInterfaceGetMergeRequestLabelEventCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, request, event}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestLabelEvent", reflect.TypeOf((*MockResourceLabelEventsServiceInterface)(nil).GetMergeRequestLabelEvent), varargs...)
	return &MockResourceLabelEventsServiceInterfaceGetMergeRequestLabelEventCall{Call: call}
}

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

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

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

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

// ListGroupEpicLabelEvents mocks base method.
func (m *MockResourceLabelEventsServiceInterface) ListGroupEpicLabelEvents(gid any, epic int64, opt *gitlab.ListLabelEventsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.LabelEvent, *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, "ListGroupEpicLabelEvents", varargs...)
	ret0, _ := ret[0].([]*gitlab.LabelEvent)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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