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

// 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"
)

// MockGroupRepositoryStorageMoveServiceInterface is a mock of GroupRepositoryStorageMoveServiceInterface interface.
type MockGroupRepositoryStorageMoveServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder is the mock recorder for MockGroupRepositoryStorageMoveServiceInterface.
type MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder struct {
	mock *MockGroupRepositoryStorageMoveServiceInterface
}

// NewMockGroupRepositoryStorageMoveServiceInterface creates a new mock instance.
func NewMockGroupRepositoryStorageMoveServiceInterface(ctrl *gomock.Controller) *MockGroupRepositoryStorageMoveServiceInterface {
	mock := &MockGroupRepositoryStorageMoveServiceInterface{ctrl: ctrl}
	mock.recorder = &MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// GetStorageMove indicates an expected call of GetStorageMove.
func (mr *MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder) GetStorageMove(repositoryStorage any, options ...any) *MockGroupRepositoryStorageMoveServiceInterfaceGetStorageMoveCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{repositoryStorage}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageMove", reflect.TypeOf((*MockGroupRepositoryStorageMoveServiceInterface)(nil).GetStorageMove), varargs...)
	return &MockGroupRepositoryStorageMoveServiceInterfaceGetStorageMoveCall{Call: call}
}

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

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

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

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

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

// GetStorageMoveForGroup indicates an expected call of GetStorageMoveForGroup.
func (mr *MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder) GetStorageMoveForGroup(group, repositoryStorage any, options ...any) *MockGroupRepositoryStorageMoveServiceInterfaceGetStorageMoveForGroupCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{group, repositoryStorage}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageMoveForGroup", reflect.TypeOf((*MockGroupRepositoryStorageMoveServiceInterface)(nil).GetStorageMoveForGroup), varargs...)
	return &MockGroupRepositoryStorageMoveServiceInterfaceGetStorageMoveForGroupCall{Call: call}
}

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesCall) Do(f func(gitlab.RetrieveAllGroupStorageMovesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GroupRepositoryStorageMove, *gitlab.Response, error)) *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesCall) DoAndReturn(f func(gitlab.RetrieveAllGroupStorageMovesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GroupRepositoryStorageMove, *gitlab.Response, error)) *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RetrieveAllStorageMovesForGroup mocks base method.
func (m *MockGroupRepositoryStorageMoveServiceInterface) RetrieveAllStorageMovesForGroup(group int, opts gitlab.RetrieveAllGroupStorageMovesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.GroupRepositoryStorageMove, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{group, opts}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RetrieveAllStorageMovesForGroup", varargs...)
	ret0, _ := ret[0].([]*gitlab.GroupRepositoryStorageMove)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RetrieveAllStorageMovesForGroup indicates an expected call of RetrieveAllStorageMovesForGroup.
func (mr *MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder) RetrieveAllStorageMovesForGroup(group, opts any, options ...any) *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesForGroupCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{group, opts}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveAllStorageMovesForGroup", reflect.TypeOf((*MockGroupRepositoryStorageMoveServiceInterface)(nil).RetrieveAllStorageMovesForGroup), varargs...)
	return &MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesForGroupCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesForGroupCall) Do(f func(int, gitlab.RetrieveAllGroupStorageMovesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GroupRepositoryStorageMove, *gitlab.Response, error)) *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesForGroupCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesForGroupCall) DoAndReturn(f func(int, gitlab.RetrieveAllGroupStorageMovesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.GroupRepositoryStorageMove, *gitlab.Response, error)) *MockGroupRepositoryStorageMoveServiceInterfaceRetrieveAllStorageMovesForGroupCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

// ScheduleStorageMoveForGroup mocks base method.
func (m *MockGroupRepositoryStorageMoveServiceInterface) ScheduleStorageMoveForGroup(group int, opts gitlab.ScheduleStorageMoveForGroupOptions, options ...gitlab.RequestOptionFunc) (*gitlab.GroupRepositoryStorageMove, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{group, opts}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScheduleStorageMoveForGroup", varargs...)
	ret0, _ := ret[0].(*gitlab.GroupRepositoryStorageMove)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ScheduleStorageMoveForGroup indicates an expected call of ScheduleStorageMoveForGroup.
func (mr *MockGroupRepositoryStorageMoveServiceInterfaceMockRecorder) ScheduleStorageMoveForGroup(group, opts any, options ...any) *MockGroupRepositoryStorageMoveServiceInterfaceScheduleStorageMoveForGroupCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{group, opts}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleStorageMoveForGroup", reflect.TypeOf((*MockGroupRepositoryStorageMoveServiceInterface)(nil).ScheduleStorageMoveForGroup), varargs...)
	return &MockGroupRepositoryStorageMoveServiceInterfaceScheduleStorageMoveForGroupCall{Call: call}
}

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

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

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

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