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

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

import (
	reflect "reflect"

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

// MockServicesServiceInterface is a mock of ServicesServiceInterface interface.
type MockServicesServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockServicesServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockServicesServiceInterfaceMockRecorder is the mock recorder for MockServicesServiceInterface.
type MockServicesServiceInterfaceMockRecorder struct {
	mock *MockServicesServiceInterface
}

// NewMockServicesServiceInterface creates a new mock instance.
func NewMockServicesServiceInterface(ctrl *gomock.Controller) *MockServicesServiceInterface {
	mock := &MockServicesServiceInterface{ctrl: ctrl}
	mock.recorder = &MockServicesServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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