// Code generated by MockGen. DO NOT EDIT.
// Source: ./fs.go

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

import (
	os "os"
	reflect "reflect"

	billy "github.com/go-git/go-billy/v5"
	gomock "github.com/golang/mock/gomock"
)

// MockFS is a mock of FS interface.
type MockFS struct {
	ctrl     *gomock.Controller
	recorder *MockFSMockRecorder
}

// MockFSMockRecorder is the mock recorder for MockFS.
type MockFSMockRecorder struct {
	mock *MockFS
}

// NewMockFS creates a new mock instance.
func NewMockFS(ctrl *gomock.Controller) *MockFS {
	mock := &MockFS{ctrl: ctrl}
	mock.recorder = &MockFSMockRecorder{mock}
	return mock
}

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

// CheckExistsOrWrite mocks base method.
func (m *MockFS) CheckExistsOrWrite(filename string, data []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckExistsOrWrite", filename, data)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckExistsOrWrite indicates an expected call of CheckExistsOrWrite.
func (mr *MockFSMockRecorder) CheckExistsOrWrite(filename, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckExistsOrWrite", reflect.TypeOf((*MockFS)(nil).CheckExistsOrWrite), filename, data)
}

// Chroot mocks base method.
func (m *MockFS) Chroot(path string) (billy.Filesystem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chroot", path)
	ret0, _ := ret[0].(billy.Filesystem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Chroot indicates an expected call of Chroot.
func (mr *MockFSMockRecorder) Chroot(path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chroot", reflect.TypeOf((*MockFS)(nil).Chroot), path)
}

// Create mocks base method.
func (m *MockFS) Create(filename string) (billy.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", filename)
	ret0, _ := ret[0].(billy.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockFSMockRecorder) Create(filename interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFS)(nil).Create), filename)
}

// Exists mocks base method.
func (m *MockFS) Exists(path string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", path)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exists indicates an expected call of Exists.
func (mr *MockFSMockRecorder) Exists(path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockFS)(nil).Exists), path)
}

// ExistsOrDie mocks base method.
func (m *MockFS) ExistsOrDie(path string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistsOrDie", path)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExistsOrDie indicates an expected call of ExistsOrDie.
func (mr *MockFSMockRecorder) ExistsOrDie(path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsOrDie", reflect.TypeOf((*MockFS)(nil).ExistsOrDie), path)
}

// Join mocks base method.
func (m *MockFS) Join(elem ...string) string {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range elem {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Join", varargs...)
	ret0, _ := ret[0].(string)
	return ret0
}

// Join indicates an expected call of Join.
func (mr *MockFSMockRecorder) Join(elem ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Join", reflect.TypeOf((*MockFS)(nil).Join), elem...)
}

// Lstat mocks base method.
func (m *MockFS) Lstat(filename string) (os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Lstat", filename)
	ret0, _ := ret[0].(os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Lstat indicates an expected call of Lstat.
func (mr *MockFSMockRecorder) Lstat(filename interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lstat", reflect.TypeOf((*MockFS)(nil).Lstat), filename)
}

// MkdirAll mocks base method.
func (m *MockFS) MkdirAll(filename string, perm os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MkdirAll", filename, perm)
	ret0, _ := ret[0].(error)
	return ret0
}

// MkdirAll indicates an expected call of MkdirAll.
func (mr *MockFSMockRecorder) MkdirAll(filename, perm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockFS)(nil).MkdirAll), filename, perm)
}

// Open mocks base method.
func (m *MockFS) Open(filename string) (billy.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Open", filename)
	ret0, _ := ret[0].(billy.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Open indicates an expected call of Open.
func (mr *MockFSMockRecorder) Open(filename interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockFS)(nil).Open), filename)
}

// OpenFile mocks base method.
func (m *MockFS) OpenFile(filename string, flag int, perm os.FileMode) (billy.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenFile", filename, flag, perm)
	ret0, _ := ret[0].(billy.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenFile indicates an expected call of OpenFile.
func (mr *MockFSMockRecorder) OpenFile(filename, flag, perm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenFile", reflect.TypeOf((*MockFS)(nil).OpenFile), filename, flag, perm)
}

// ReadDir mocks base method.
func (m *MockFS) ReadDir(path string) ([]os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadDir", path)
	ret0, _ := ret[0].([]os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadDir indicates an expected call of ReadDir.
func (mr *MockFSMockRecorder) ReadDir(path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadDir", reflect.TypeOf((*MockFS)(nil).ReadDir), path)
}

// ReadFile mocks base method.
func (m *MockFS) ReadFile(filename string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadFile", filename)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadFile indicates an expected call of ReadFile.
func (mr *MockFSMockRecorder) ReadFile(filename interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockFS)(nil).ReadFile), filename)
}

// ReadJson mocks base method.
func (m *MockFS) ReadJson(filename string, o interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadJson", filename, o)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadJson indicates an expected call of ReadJson.
func (mr *MockFSMockRecorder) ReadJson(filename, o interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadJson", reflect.TypeOf((*MockFS)(nil).ReadJson), filename, o)
}

// ReadYamls mocks base method.
func (m *MockFS) ReadYamls(filename string, o ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{filename}
	for _, a := range o {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReadYamls", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadYamls indicates an expected call of ReadYamls.
func (mr *MockFSMockRecorder) ReadYamls(filename interface{}, o ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{filename}, o...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadYamls", reflect.TypeOf((*MockFS)(nil).ReadYamls), varargs...)
}

// Readlink mocks base method.
func (m *MockFS) Readlink(link string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Readlink", link)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Readlink indicates an expected call of Readlink.
func (mr *MockFSMockRecorder) Readlink(link interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Readlink", reflect.TypeOf((*MockFS)(nil).Readlink), link)
}

// Remove mocks base method.
func (m *MockFS) Remove(filename string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Remove", filename)
	ret0, _ := ret[0].(error)
	return ret0
}

// Remove indicates an expected call of Remove.
func (mr *MockFSMockRecorder) Remove(filename interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockFS)(nil).Remove), filename)
}

// Rename mocks base method.
func (m *MockFS) Rename(oldpath, newpath string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rename", oldpath, newpath)
	ret0, _ := ret[0].(error)
	return ret0
}

// Rename indicates an expected call of Rename.
func (mr *MockFSMockRecorder) Rename(oldpath, newpath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockFS)(nil).Rename), oldpath, newpath)
}

// Root mocks base method.
func (m *MockFS) Root() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Root")
	ret0, _ := ret[0].(string)
	return ret0
}

// Root indicates an expected call of Root.
func (mr *MockFSMockRecorder) Root() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockFS)(nil).Root))
}

// Stat mocks base method.
func (m *MockFS) Stat(filename string) (os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stat", filename)
	ret0, _ := ret[0].(os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stat indicates an expected call of Stat.
func (mr *MockFSMockRecorder) Stat(filename interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockFS)(nil).Stat), filename)
}

// Symlink mocks base method.
func (m *MockFS) Symlink(target, link string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Symlink", target, link)
	ret0, _ := ret[0].(error)
	return ret0
}

// Symlink indicates an expected call of Symlink.
func (mr *MockFSMockRecorder) Symlink(target, link interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Symlink", reflect.TypeOf((*MockFS)(nil).Symlink), target, link)
}

// TempFile mocks base method.
func (m *MockFS) TempFile(dir, prefix string) (billy.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TempFile", dir, prefix)
	ret0, _ := ret[0].(billy.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TempFile indicates an expected call of TempFile.
func (mr *MockFSMockRecorder) TempFile(dir, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TempFile", reflect.TypeOf((*MockFS)(nil).TempFile), dir, prefix)
}

// WriteJson mocks base method.
func (m *MockFS) WriteJson(filename string, o interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteJson", filename, o)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteJson indicates an expected call of WriteJson.
func (mr *MockFSMockRecorder) WriteJson(filename, o interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteJson", reflect.TypeOf((*MockFS)(nil).WriteJson), filename, o)
}

// WriteYamls mocks base method.
func (m *MockFS) WriteYamls(filename string, o ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{filename}
	for _, a := range o {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WriteYamls", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteYamls indicates an expected call of WriteYamls.
func (mr *MockFSMockRecorder) WriteYamls(filename interface{}, o ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{filename}, o...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteYamls", reflect.TypeOf((*MockFS)(nil).WriteYamls), varargs...)
}
