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

package testing

import (
	reflect "reflect"

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

// MockGeoSitesServiceInterface is a mock of GeoSitesServiceInterface interface.
type MockGeoSitesServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockGeoSitesServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockGeoSitesServiceInterfaceMockRecorder is the mock recorder for MockGeoSitesServiceInterface.
type MockGeoSitesServiceInterfaceMockRecorder struct {
	mock *MockGeoSitesServiceInterface
}

// NewMockGeoSitesServiceInterface creates a new mock instance.
func NewMockGeoSitesServiceInterface(ctrl *gomock.Controller) *MockGeoSitesServiceInterface {
	mock := &MockGeoSitesServiceInterface{ctrl: ctrl}
	mock.recorder = &MockGeoSitesServiceInterfaceMockRecorder{mock}
	return mock
}

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

// CreateGeoSite mocks base method.
func (m *MockGeoSitesServiceInterface) CreateGeoSite(arg0 *gitlab.CreateGeoSitesOptions, arg1 ...gitlab.RequestOptionFunc) (*gitlab.GeoSite, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGeoSite", varargs...)
	ret0, _ := ret[0].(*gitlab.GeoSite)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateGeoSite indicates an expected call of CreateGeoSite.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) CreateGeoSite(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceCreateGeoSiteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGeoSite", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).CreateGeoSite), varargs...)
	return &MockGeoSitesServiceInterfaceCreateGeoSiteCall{Call: call}
}

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

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

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

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

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

// DeleteGeoSite indicates an expected call of DeleteGeoSite.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) DeleteGeoSite(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceDeleteGeoSiteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGeoSite", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).DeleteGeoSite), varargs...)
	return &MockGeoSitesServiceInterfaceDeleteGeoSiteCall{Call: call}
}

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

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

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

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

// EditGeoSite mocks base method.
func (m *MockGeoSitesServiceInterface) EditGeoSite(arg0 int64, arg1 *gitlab.EditGeoSiteOptions, arg2 ...gitlab.RequestOptionFunc) (*gitlab.GeoSite, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EditGeoSite", varargs...)
	ret0, _ := ret[0].(*gitlab.GeoSite)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EditGeoSite indicates an expected call of EditGeoSite.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) EditGeoSite(arg0, arg1 any, arg2 ...any) *MockGeoSitesServiceInterfaceEditGeoSiteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditGeoSite", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).EditGeoSite), varargs...)
	return &MockGeoSitesServiceInterfaceEditGeoSiteCall{Call: call}
}

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

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

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

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

// GetGeoSite mocks base method.
func (m *MockGeoSitesServiceInterface) GetGeoSite(arg0 int64, arg1 ...gitlab.RequestOptionFunc) (*gitlab.GeoSite, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGeoSite", varargs...)
	ret0, _ := ret[0].(*gitlab.GeoSite)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGeoSite indicates an expected call of GetGeoSite.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) GetGeoSite(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceGetGeoSiteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoSite", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).GetGeoSite), varargs...)
	return &MockGeoSitesServiceInterfaceGetGeoSiteCall{Call: call}
}

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

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

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

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

// GetStatusOfGeoSite mocks base method.
func (m *MockGeoSitesServiceInterface) GetStatusOfGeoSite(arg0 int64, arg1 ...gitlab.RequestOptionFunc) (*gitlab.GeoSiteStatus, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStatusOfGeoSite", varargs...)
	ret0, _ := ret[0].(*gitlab.GeoSiteStatus)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStatusOfGeoSite indicates an expected call of GetStatusOfGeoSite.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) GetStatusOfGeoSite(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceGetStatusOfGeoSiteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatusOfGeoSite", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).GetStatusOfGeoSite), varargs...)
	return &MockGeoSitesServiceInterfaceGetStatusOfGeoSiteCall{Call: call}
}

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

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

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

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

// ListGeoSites mocks base method.
func (m *MockGeoSitesServiceInterface) ListGeoSites(arg0 *gitlab.ListGeoSitesOptions, arg1 ...gitlab.RequestOptionFunc) ([]*gitlab.GeoSite, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGeoSites", varargs...)
	ret0, _ := ret[0].([]*gitlab.GeoSite)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListGeoSites indicates an expected call of ListGeoSites.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) ListGeoSites(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceListGeoSitesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoSites", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).ListGeoSites), varargs...)
	return &MockGeoSitesServiceInterfaceListGeoSitesCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGeoSitesServiceInterfaceListGeoSitesCall) Do(f func(*gitlab.ListGeoSitesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GeoSite, *gitlab.Response, error)) *MockGeoSitesServiceInterfaceListGeoSitesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGeoSitesServiceInterfaceListGeoSitesCall) DoAndReturn(f func(*gitlab.ListGeoSitesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GeoSite, *gitlab.Response, error)) *MockGeoSitesServiceInterfaceListGeoSitesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListStatusOfAllGeoSites mocks base method.
func (m *MockGeoSitesServiceInterface) ListStatusOfAllGeoSites(arg0 *gitlab.ListStatusOfAllGeoSitesOptions, arg1 ...gitlab.RequestOptionFunc) ([]*gitlab.GeoSiteStatus, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListStatusOfAllGeoSites", varargs...)
	ret0, _ := ret[0].([]*gitlab.GeoSiteStatus)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListStatusOfAllGeoSites indicates an expected call of ListStatusOfAllGeoSites.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) ListStatusOfAllGeoSites(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceListStatusOfAllGeoSitesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStatusOfAllGeoSites", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).ListStatusOfAllGeoSites), varargs...)
	return &MockGeoSitesServiceInterfaceListStatusOfAllGeoSitesCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGeoSitesServiceInterfaceListStatusOfAllGeoSitesCall) Do(f func(*gitlab.ListStatusOfAllGeoSitesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GeoSiteStatus, *gitlab.Response, error)) *MockGeoSitesServiceInterfaceListStatusOfAllGeoSitesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGeoSitesServiceInterfaceListStatusOfAllGeoSitesCall) DoAndReturn(f func(*gitlab.ListStatusOfAllGeoSitesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GeoSiteStatus, *gitlab.Response, error)) *MockGeoSitesServiceInterfaceListStatusOfAllGeoSitesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RepairGeoSite mocks base method.
func (m *MockGeoSitesServiceInterface) RepairGeoSite(arg0 int64, arg1 ...gitlab.RequestOptionFunc) (*gitlab.GeoSite, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RepairGeoSite", varargs...)
	ret0, _ := ret[0].(*gitlab.GeoSite)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RepairGeoSite indicates an expected call of RepairGeoSite.
func (mr *MockGeoSitesServiceInterfaceMockRecorder) RepairGeoSite(arg0 any, arg1 ...any) *MockGeoSitesServiceInterfaceRepairGeoSiteCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RepairGeoSite", reflect.TypeOf((*MockGeoSitesServiceInterface)(nil).RepairGeoSite), varargs...)
	return &MockGeoSitesServiceInterfaceRepairGeoSiteCall{Call: call}
}

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

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

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

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