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

package testing

import (
	reflect "reflect"

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

// MockRepositoryFilesServiceInterface is a mock of RepositoryFilesServiceInterface interface.
type MockRepositoryFilesServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryFilesServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockRepositoryFilesServiceInterfaceMockRecorder is the mock recorder for MockRepositoryFilesServiceInterface.
type MockRepositoryFilesServiceInterfaceMockRecorder struct {
	mock *MockRepositoryFilesServiceInterface
}

// NewMockRepositoryFilesServiceInterface creates a new mock instance.
func NewMockRepositoryFilesServiceInterface(ctrl *gomock.Controller) *MockRepositoryFilesServiceInterface {
	mock := &MockRepositoryFilesServiceInterface{ctrl: ctrl}
	mock.recorder = &MockRepositoryFilesServiceInterfaceMockRecorder{mock}
	return mock
}

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

// CreateFile mocks base method.
func (m *MockRepositoryFilesServiceInterface) CreateFile(pid any, fileName string, opt *gitlab.CreateFileOptions, options ...gitlab.RequestOptionFunc) (*gitlab.FileInfo, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, fileName, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFile", varargs...)
	ret0, _ := ret[0].(*gitlab.FileInfo)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateFile indicates an expected call of CreateFile.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) CreateFile(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceCreateFileCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFile", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).CreateFile), varargs...)
	return &MockRepositoryFilesServiceInterfaceCreateFileCall{Call: call}
}

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

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

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

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

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

// DeleteFile indicates an expected call of DeleteFile.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) DeleteFile(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceDeleteFileCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFile", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).DeleteFile), varargs...)
	return &MockRepositoryFilesServiceInterfaceDeleteFileCall{Call: call}
}

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

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

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

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

// GetFile mocks base method.
func (m *MockRepositoryFilesServiceInterface) GetFile(pid any, fileName string, opt *gitlab.GetFileOptions, options ...gitlab.RequestOptionFunc) (*gitlab.File, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, fileName, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFile", varargs...)
	ret0, _ := ret[0].(*gitlab.File)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetFile indicates an expected call of GetFile.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) GetFile(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceGetFileCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFile", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).GetFile), varargs...)
	return &MockRepositoryFilesServiceInterfaceGetFileCall{Call: call}
}

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

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

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

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

// GetFileBlame mocks base method.
func (m *MockRepositoryFilesServiceInterface) GetFileBlame(pid any, file string, opt *gitlab.GetFileBlameOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.FileBlameRange, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, file, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFileBlame", varargs...)
	ret0, _ := ret[0].([]*gitlab.FileBlameRange)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetFileBlame indicates an expected call of GetFileBlame.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) GetFileBlame(pid, file, opt any, options ...any) *MockRepositoryFilesServiceInterfaceGetFileBlameCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, file, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileBlame", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).GetFileBlame), varargs...)
	return &MockRepositoryFilesServiceInterfaceGetFileBlameCall{Call: call}
}

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

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

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

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

// GetFileMetaData mocks base method.
func (m *MockRepositoryFilesServiceInterface) GetFileMetaData(pid any, fileName string, opt *gitlab.GetFileMetaDataOptions, options ...gitlab.RequestOptionFunc) (*gitlab.File, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, fileName, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFileMetaData", varargs...)
	ret0, _ := ret[0].(*gitlab.File)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetFileMetaData indicates an expected call of GetFileMetaData.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) GetFileMetaData(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceGetFileMetaDataCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileMetaData", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).GetFileMetaData), varargs...)
	return &MockRepositoryFilesServiceInterfaceGetFileMetaDataCall{Call: call}
}

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

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

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

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

// GetRawFile mocks base method.
func (m *MockRepositoryFilesServiceInterface) GetRawFile(pid any, fileName string, opt *gitlab.GetRawFileOptions, options ...gitlab.RequestOptionFunc) ([]byte, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, fileName, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRawFile", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRawFile indicates an expected call of GetRawFile.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) GetRawFile(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceGetRawFileCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawFile", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).GetRawFile), varargs...)
	return &MockRepositoryFilesServiceInterfaceGetRawFileCall{Call: call}
}

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

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

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

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

// GetRawFileMetaData mocks base method.
func (m *MockRepositoryFilesServiceInterface) GetRawFileMetaData(pid any, fileName string, opt *gitlab.GetRawFileOptions, options ...gitlab.RequestOptionFunc) (*gitlab.File, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, fileName, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRawFileMetaData", varargs...)
	ret0, _ := ret[0].(*gitlab.File)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRawFileMetaData indicates an expected call of GetRawFileMetaData.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) GetRawFileMetaData(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceGetRawFileMetaDataCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawFileMetaData", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).GetRawFileMetaData), varargs...)
	return &MockRepositoryFilesServiceInterfaceGetRawFileMetaDataCall{Call: call}
}

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

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

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

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

// UpdateFile mocks base method.
func (m *MockRepositoryFilesServiceInterface) UpdateFile(pid any, fileName string, opt *gitlab.UpdateFileOptions, options ...gitlab.RequestOptionFunc) (*gitlab.FileInfo, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, fileName, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFile", varargs...)
	ret0, _ := ret[0].(*gitlab.FileInfo)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateFile indicates an expected call of UpdateFile.
func (mr *MockRepositoryFilesServiceInterfaceMockRecorder) UpdateFile(pid, fileName, opt any, options ...any) *MockRepositoryFilesServiceInterfaceUpdateFileCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, fileName, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFile", reflect.TypeOf((*MockRepositoryFilesServiceInterface)(nil).UpdateFile), varargs...)
	return &MockRepositoryFilesServiceInterfaceUpdateFileCall{Call: call}
}

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

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

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

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