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

package testing

import (
	bytes "bytes"
	io "io"
	reflect "reflect"

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

// MockGroupsServiceInterface is a mock of GroupsServiceInterface interface.
type MockGroupsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockGroupsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockGroupsServiceInterfaceMockRecorder is the mock recorder for MockGroupsServiceInterface.
type MockGroupsServiceInterfaceMockRecorder struct {
	mock *MockGroupsServiceInterface
}

// NewMockGroupsServiceInterface creates a new mock instance.
func NewMockGroupsServiceInterface(ctrl *gomock.Controller) *MockGroupsServiceInterface {
	mock := &MockGroupsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockGroupsServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ArchiveGroup mocks base method.
func (m *MockGroupsServiceInterface) ArchiveGroup(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, "ArchiveGroup", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeleteGroupCustomHeader indicates an expected call of DeleteGroupCustomHeader.
func (mr *MockGroupsServiceInterfaceMockRecorder) DeleteGroupCustomHeader(gid, hook, key any, options ...any) *MockGroupsServiceInterfaceDeleteGroupCustomHeaderCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, hook, key}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupCustomHeader", reflect.TypeOf((*MockGroupsServiceInterface)(nil).DeleteGroupCustomHeader), varargs...)
	return &MockGroupsServiceInterfaceDeleteGroupCustomHeaderCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// DeleteGroupHookURLVariable indicates an expected call of DeleteGroupHookURLVariable.
func (mr *MockGroupsServiceInterfaceMockRecorder) DeleteGroupHookURLVariable(gid, hook, key any, options ...any) *MockGroupsServiceInterfaceDeleteGroupHookURLVariableCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, hook, key}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupHookURLVariable", reflect.TypeOf((*MockGroupsServiceInterface)(nil).DeleteGroupHookURLVariable), varargs...)
	return &MockGroupsServiceInterfaceDeleteGroupHookURLVariableCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// DeleteGroupLDAPLinkForProvider indicates an expected call of DeleteGroupLDAPLinkForProvider.
func (mr *MockGroupsServiceInterfaceMockRecorder) DeleteGroupLDAPLinkForProvider(gid, provider, cn any, options ...any) *MockGroupsServiceInterfaceDeleteGroupLDAPLinkForProviderCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, provider, cn}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupLDAPLinkForProvider", reflect.TypeOf((*MockGroupsServiceInterface)(nil).DeleteGroupLDAPLinkForProvider), varargs...)
	return &MockGroupsServiceInterfaceDeleteGroupLDAPLinkForProviderCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// DeleteGroupPushRule mocks base method.
func (m *MockGroupsServiceInterface) DeleteGroupPushRule(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, "DeleteGroupPushRule", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGroupsServiceInterfaceListGroupsCall) Do(f func(*gitlab.ListGroupsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Group, *gitlab.Response, error)) *MockGroupsServiceInterfaceListGroupsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGroupsServiceInterfaceListGroupsCall) DoAndReturn(f func(*gitlab.ListGroupsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Group, *gitlab.Response, error)) *MockGroupsServiceInterfaceListGroupsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ResendGroupHookEvent indicates an expected call of ResendGroupHookEvent.
func (mr *MockGroupsServiceInterfaceMockRecorder) ResendGroupHookEvent(gid, hook, hookEventID any, options ...any) *MockGroupsServiceInterfaceResendGroupHookEventCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, hook, hookEventID}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendGroupHookEvent", reflect.TypeOf((*MockGroupsServiceInterface)(nil).ResendGroupHookEvent), varargs...)
	return &MockGroupsServiceInterfaceResendGroupHookEventCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// RevokeServiceAccountPersonalAccessToken indicates an expected call of RevokeServiceAccountPersonalAccessToken.
func (mr *MockGroupsServiceInterfaceMockRecorder) RevokeServiceAccountPersonalAccessToken(gid, serviceAccount, token any, options ...any) *MockGroupsServiceInterfaceRevokeServiceAccountPersonalAccessTokenCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, serviceAccount, token}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeServiceAccountPersonalAccessToken", reflect.TypeOf((*MockGroupsServiceInterface)(nil).RevokeServiceAccountPersonalAccessToken), varargs...)
	return &MockGroupsServiceInterfaceRevokeServiceAccountPersonalAccessTokenCall{Call: call}
}

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

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

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

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

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

// RotateServiceAccountPersonalAccessToken indicates an expected call of RotateServiceAccountPersonalAccessToken.
func (mr *MockGroupsServiceInterfaceMockRecorder) RotateServiceAccountPersonalAccessToken(gid, serviceAccount, token, opt any, options ...any) *MockGroupsServiceInterfaceRotateServiceAccountPersonalAccessTokenCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, serviceAccount, token, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateServiceAccountPersonalAccessToken", reflect.TypeOf((*MockGroupsServiceInterface)(nil).RotateServiceAccountPersonalAccessToken), varargs...)
	return &MockGroupsServiceInterfaceRotateServiceAccountPersonalAccessTokenCall{Call: call}
}

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

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

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

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

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

// SearchGroup indicates an expected call of SearchGroup.
func (mr *MockGroupsServiceInterfaceMockRecorder) SearchGroup(query any, options ...any) *MockGroupsServiceInterfaceSearchGroupCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{query}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGroup", reflect.TypeOf((*MockGroupsServiceInterface)(nil).SearchGroup), varargs...)
	return &MockGroupsServiceInterfaceSearchGroupCall{Call: call}
}

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

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

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

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

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

// SetGroupCustomHeader indicates an expected call of SetGroupCustomHeader.
func (mr *MockGroupsServiceInterfaceMockRecorder) SetGroupCustomHeader(gid, hook, key, opt any, options ...any) *MockGroupsServiceInterfaceSetGroupCustomHeaderCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, hook, key, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGroupCustomHeader", reflect.TypeOf((*MockGroupsServiceInterface)(nil).SetGroupCustomHeader), varargs...)
	return &MockGroupsServiceInterfaceSetGroupCustomHeaderCall{Call: call}
}

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

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

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

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

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

// SetGroupHookURLVariable indicates an expected call of SetGroupHookURLVariable.
func (mr *MockGroupsServiceInterfaceMockRecorder) SetGroupHookURLVariable(gid, hook, key, opt any, options ...any) *MockGroupsServiceInterfaceSetGroupHookURLVariableCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, hook, key, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGroupHookURLVariable", reflect.TypeOf((*MockGroupsServiceInterface)(nil).SetGroupHookURLVariable), varargs...)
	return &MockGroupsServiceInterfaceSetGroupHookURLVariableCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// SyncGroupWithLDAP mocks base method.
func (m *MockGroupsServiceInterface) SyncGroupWithLDAP(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, "SyncGroupWithLDAP", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// TriggerTestGroupHook indicates an expected call of TriggerTestGroupHook.
func (mr *MockGroupsServiceInterfaceMockRecorder) TriggerTestGroupHook(pid, hook, trigger any, options ...any) *MockGroupsServiceInterfaceTriggerTestGroupHookCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, hook, trigger}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TriggerTestGroupHook", reflect.TypeOf((*MockGroupsServiceInterface)(nil).TriggerTestGroupHook), varargs...)
	return &MockGroupsServiceInterfaceTriggerTestGroupHookCall{Call: call}
}

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

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

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

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

// UnarchiveGroup mocks base method.
func (m *MockGroupsServiceInterface) UnarchiveGroup(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, "UnarchiveGroup", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UploadAvatar mocks base method.
func (m *MockGroupsServiceInterface) UploadAvatar(gid any, avatar io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.Group, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{gid, avatar, filename}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadAvatar", varargs...)
	ret0, _ := ret[0].(*gitlab.Group)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UploadAvatar indicates an expected call of UploadAvatar.
func (mr *MockGroupsServiceInterfaceMockRecorder) UploadAvatar(gid, avatar, filename any, options ...any) *MockGroupsServiceInterfaceUploadAvatarCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, avatar, filename}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadAvatar", reflect.TypeOf((*MockGroupsServiceInterface)(nil).UploadAvatar), varargs...)
	return &MockGroupsServiceInterfaceUploadAvatarCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGroupsServiceInterfaceUploadAvatarCall) Do(f func(any, io.Reader, string, ...gitlab.RequestOptionFunc) (*gitlab.Group, *gitlab.Response, error)) *MockGroupsServiceInterfaceUploadAvatarCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGroupsServiceInterfaceUploadAvatarCall) DoAndReturn(f func(any, io.Reader, string, ...gitlab.RequestOptionFunc) (*gitlab.Group, *gitlab.Response, error)) *MockGroupsServiceInterfaceUploadAvatarCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
