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

package testing

import (
	reflect "reflect"

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

// MockEnterpriseUsersServiceInterface is a mock of EnterpriseUsersServiceInterface interface.
type MockEnterpriseUsersServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockEnterpriseUsersServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockEnterpriseUsersServiceInterfaceMockRecorder is the mock recorder for MockEnterpriseUsersServiceInterface.
type MockEnterpriseUsersServiceInterfaceMockRecorder struct {
	mock *MockEnterpriseUsersServiceInterface
}

// NewMockEnterpriseUsersServiceInterface creates a new mock instance.
func NewMockEnterpriseUsersServiceInterface(ctrl *gomock.Controller) *MockEnterpriseUsersServiceInterface {
	mock := &MockEnterpriseUsersServiceInterface{ctrl: ctrl}
	mock.recorder = &MockEnterpriseUsersServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// DeleteEnterpriseUser indicates an expected call of DeleteEnterpriseUser.
func (mr *MockEnterpriseUsersServiceInterfaceMockRecorder) DeleteEnterpriseUser(gid, uid, deleteOptions any, options ...any) *MockEnterpriseUsersServiceInterfaceDeleteEnterpriseUserCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, uid, deleteOptions}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEnterpriseUser", reflect.TypeOf((*MockEnterpriseUsersServiceInterface)(nil).DeleteEnterpriseUser), varargs...)
	return &MockEnterpriseUsersServiceInterfaceDeleteEnterpriseUserCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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