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

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

import (
	reflect "reflect"

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

// MockGroupMembersServiceInterface is a mock of GroupMembersServiceInterface interface.
type MockGroupMembersServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockGroupMembersServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockGroupMembersServiceInterfaceMockRecorder is the mock recorder for MockGroupMembersServiceInterface.
type MockGroupMembersServiceInterfaceMockRecorder struct {
	mock *MockGroupMembersServiceInterface
}

// NewMockGroupMembersServiceInterface creates a new mock instance.
func NewMockGroupMembersServiceInterface(ctrl *gomock.Controller) *MockGroupMembersServiceInterface {
	mock := &MockGroupMembersServiceInterface{ctrl: ctrl}
	mock.recorder = &MockGroupMembersServiceInterfaceMockRecorder{mock}
	return mock
}

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

// AddGroupMember mocks base method.
func (m *MockGroupMembersServiceInterface) AddGroupMember(gid any, opt *gitlab.AddGroupMemberOptions, 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, "AddGroupMember", varargs...)
	ret0, _ := ret[0].(*gitlab.GroupMember)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

// EditGroupMember mocks base method.
func (m *MockGroupMembersServiceInterface) EditGroupMember(gid any, user int, opt *gitlab.EditGroupMemberOptions, options ...gitlab.RequestOptionFunc) (*gitlab.GroupMember, *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, "EditGroupMember", varargs...)
	ret0, _ := ret[0].(*gitlab.GroupMember)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RemoveGroupMember mocks base method.
func (m *MockGroupMembersServiceInterface) RemoveGroupMember(gid any, user int, opt *gitlab.RemoveGroupMemberOptions, options ...gitlab.RequestOptionFunc) (*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, "RemoveGroupMember", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// ShareWithGroup mocks base method.
func (m *MockGroupMembersServiceInterface) ShareWithGroup(gid any, opt *gitlab.ShareWithGroupOptions, 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, "ShareWithGroup", varargs...)
	ret0, _ := ret[0].(*gitlab.Group)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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