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

package testing

import (
	reflect "reflect"

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

// MockIntegrationsServiceInterface is a mock of IntegrationsServiceInterface interface.
type MockIntegrationsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockIntegrationsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockIntegrationsServiceInterfaceMockRecorder is the mock recorder for MockIntegrationsServiceInterface.
type MockIntegrationsServiceInterfaceMockRecorder struct {
	mock *MockIntegrationsServiceInterface
}

// NewMockIntegrationsServiceInterface creates a new mock instance.
func NewMockIntegrationsServiceInterface(ctrl *gomock.Controller) *MockIntegrationsServiceInterface {
	mock := &MockIntegrationsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockIntegrationsServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// DisableGroupHarbor indicates an expected call of DisableGroupHarbor.
func (mr *MockIntegrationsServiceInterfaceMockRecorder) DisableGroupHarbor(gid any, options ...any) *MockIntegrationsServiceInterfaceDisableGroupHarborCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableGroupHarbor", reflect.TypeOf((*MockIntegrationsServiceInterface)(nil).DisableGroupHarbor), varargs...)
	return &MockIntegrationsServiceInterfaceDisableGroupHarborCall{Call: call}
}

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

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

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

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

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

// DisableGroupJira indicates an expected call of DisableGroupJira.
func (mr *MockIntegrationsServiceInterfaceMockRecorder) DisableGroupJira(gid any, options ...any) *MockIntegrationsServiceInterfaceDisableGroupJiraCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableGroupJira", reflect.TypeOf((*MockIntegrationsServiceInterface)(nil).DisableGroupJira), varargs...)
	return &MockIntegrationsServiceInterfaceDisableGroupJiraCall{Call: call}
}

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

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

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

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

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

// DisableGroupMicrosoftTeamsNotifications indicates an expected call of DisableGroupMicrosoftTeamsNotifications.
func (mr *MockIntegrationsServiceInterfaceMockRecorder) DisableGroupMicrosoftTeamsNotifications(gid any, options ...any) *MockIntegrationsServiceInterfaceDisableGroupMicrosoftTeamsNotificationsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableGroupMicrosoftTeamsNotifications", reflect.TypeOf((*MockIntegrationsServiceInterface)(nil).DisableGroupMicrosoftTeamsNotifications), varargs...)
	return &MockIntegrationsServiceInterfaceDisableGroupMicrosoftTeamsNotificationsCall{Call: call}
}

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

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

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

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

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

// GetGroupHarborSettings indicates an expected call of GetGroupHarborSettings.
func (mr *MockIntegrationsServiceInterfaceMockRecorder) GetGroupHarborSettings(gid any, options ...any) *MockIntegrationsServiceInterfaceGetGroupHarborSettingsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupHarborSettings", reflect.TypeOf((*MockIntegrationsServiceInterface)(nil).GetGroupHarborSettings), varargs...)
	return &MockIntegrationsServiceInterfaceGetGroupHarborSettingsCall{Call: call}
}

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

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

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

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

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

// GetGroupJiraSettings indicates an expected call of GetGroupJiraSettings.
func (mr *MockIntegrationsServiceInterfaceMockRecorder) GetGroupJiraSettings(gid any, options ...any) *MockIntegrationsServiceInterfaceGetGroupJiraSettingsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupJiraSettings", reflect.TypeOf((*MockIntegrationsServiceInterface)(nil).GetGroupJiraSettings), varargs...)
	return &MockIntegrationsServiceInterfaceGetGroupJiraSettingsCall{Call: call}
}

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

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

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

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

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

// GetGroupMicrosoftTeamsNotifications indicates an expected call of GetGroupMicrosoftTeamsNotifications.
func (mr *MockIntegrationsServiceInterfaceMockRecorder) GetGroupMicrosoftTeamsNotifications(gid any, options ...any) *MockIntegrationsServiceInterfaceGetGroupMicrosoftTeamsNotificationsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMicrosoftTeamsNotifications", reflect.TypeOf((*MockIntegrationsServiceInterface)(nil).GetGroupMicrosoftTeamsNotifications), varargs...)
	return &MockIntegrationsServiceInterfaceGetGroupMicrosoftTeamsNotificationsCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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