// Code generated by MockGen. DO NOT EDIT.
// Source: internal/interfaces/interfaces.go
//
// Generated by this command:
//
//	mockgen -source=internal/interfaces/interfaces.go -destination=internal/interfaces/mocks/mock_interfaces.go -package=mocks
//

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

import (
	context "context"
	io "io"
	http "net/http"
	os "os"
	reflect "reflect"

	interfaces "github.com/bnema/archup/internal/interfaces"
	system "github.com/bnema/archup/internal/system"
	gomock "go.uber.org/mock/gomock"
)

// MockFileSystem is a mock of FileSystem interface.
type MockFileSystem struct {
	ctrl     *gomock.Controller
	recorder *MockFileSystemMockRecorder
	isgomock struct{}
}

// MockFileSystemMockRecorder is the mock recorder for MockFileSystem.
type MockFileSystemMockRecorder struct {
	mock *MockFileSystem
}

// NewMockFileSystem creates a new mock instance.
func NewMockFileSystem(ctrl *gomock.Controller) *MockFileSystem {
	mock := &MockFileSystem{ctrl: ctrl}
	mock.recorder = &MockFileSystemMockRecorder{mock}
	return mock
}

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

// Chmod mocks base method.
func (m *MockFileSystem) Chmod(name string, mode os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chmod", name, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chmod indicates an expected call of Chmod.
func (mr *MockFileSystemMockRecorder) Chmod(name, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFileSystem)(nil).Chmod), name, mode)
}

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

// Create indicates an expected call of Create.
func (mr *MockFileSystemMockRecorder) Create(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFileSystem)(nil).Create), name)
}

// IsNotExist mocks base method.
func (m *MockFileSystem) IsNotExist(err error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsNotExist", err)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsNotExist indicates an expected call of IsNotExist.
func (mr *MockFileSystemMockRecorder) IsNotExist(err any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotExist", reflect.TypeOf((*MockFileSystem)(nil).IsNotExist), err)
}

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

// MkdirAll indicates an expected call of MkdirAll.
func (mr *MockFileSystemMockRecorder) MkdirAll(path, perm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockFileSystem)(nil).MkdirAll), path, perm)
}

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

// Open indicates an expected call of Open.
func (mr *MockFileSystemMockRecorder) Open(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockFileSystem)(nil).Open), name)
}

// ReadFile mocks base method.
func (m *MockFileSystem) 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 *MockFileSystemMockRecorder) ReadFile(filename any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockFileSystem)(nil).ReadFile), filename)
}

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

// RemoveAll indicates an expected call of RemoveAll.
func (mr *MockFileSystemMockRecorder) RemoveAll(path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockFileSystem)(nil).RemoveAll), path)
}

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

// Stat indicates an expected call of Stat.
func (mr *MockFileSystemMockRecorder) Stat(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockFileSystem)(nil).Stat), name)
}

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

// WriteFile indicates an expected call of WriteFile.
func (mr *MockFileSystemMockRecorder) WriteFile(filename, data, perm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockFileSystem)(nil).WriteFile), filename, data, perm)
}

// MockCommandExecutor is a mock of CommandExecutor interface.
type MockCommandExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockCommandExecutorMockRecorder
	isgomock struct{}
}

// MockCommandExecutorMockRecorder is the mock recorder for MockCommandExecutor.
type MockCommandExecutorMockRecorder struct {
	mock *MockCommandExecutor
}

// NewMockCommandExecutor creates a new mock instance.
func NewMockCommandExecutor(ctrl *gomock.Controller) *MockCommandExecutor {
	mock := &MockCommandExecutor{ctrl: ctrl}
	mock.recorder = &MockCommandExecutorMockRecorder{mock}
	return mock
}

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

// Execute mocks base method.
func (m *MockCommandExecutor) Execute(name string, args ...string) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Execute", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Execute indicates an expected call of Execute.
func (mr *MockCommandExecutorMockRecorder) Execute(name any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockCommandExecutor)(nil).Execute), varargs...)
}

// MockSystemExecutor is a mock of SystemExecutor interface.
type MockSystemExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockSystemExecutorMockRecorder
	isgomock struct{}
}

// MockSystemExecutorMockRecorder is the mock recorder for MockSystemExecutor.
type MockSystemExecutorMockRecorder struct {
	mock *MockSystemExecutor
}

// NewMockSystemExecutor creates a new mock instance.
func NewMockSystemExecutor(ctrl *gomock.Controller) *MockSystemExecutor {
	mock := &MockSystemExecutor{ctrl: ctrl}
	mock.recorder = &MockSystemExecutorMockRecorder{mock}
	return mock
}

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

// DetectCPUInfo mocks base method.
func (m *MockSystemExecutor) DetectCPUInfo() (*system.CPUInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetectCPUInfo")
	ret0, _ := ret[0].(*system.CPUInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RunSimple mocks base method.
func (m *MockSystemExecutor) RunSimple(command string, args ...string) system.CommandResult {
	m.ctrl.T.Helper()
	varargs := []any{command}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunSimple", varargs...)
	ret0, _ := ret[0].(system.CommandResult)
	return ret0
}

// RunSimple indicates an expected call of RunSimple.
func (mr *MockSystemExecutorMockRecorder) RunSimple(command any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{command}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunSimple", reflect.TypeOf((*MockSystemExecutor)(nil).RunSimple), varargs...)
}

// MockChrootSession is a mock of ChrootSession interface.
type MockChrootSession struct {
	ctrl     *gomock.Controller
	recorder *MockChrootSessionMockRecorder
	isgomock struct{}
}

// MockChrootSessionMockRecorder is the mock recorder for MockChrootSession.
type MockChrootSessionMockRecorder struct {
	mock *MockChrootSession
}

// NewMockChrootSession creates a new mock instance.
func NewMockChrootSession(ctrl *gomock.Controller) *MockChrootSession {
	mock := &MockChrootSession{ctrl: ctrl}
	mock.recorder = &MockChrootSessionMockRecorder{mock}
	return mock
}

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

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

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

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

// Exec indicates an expected call of Exec.
func (mr *MockChrootSessionMockRecorder) Exec(command any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockChrootSession)(nil).Exec), command)
}

// ExecWithContext mocks base method.
func (m *MockChrootSession) ExecWithContext(ctx context.Context, command string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecWithContext", ctx, command)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecWithContext indicates an expected call of ExecWithContext.
func (mr *MockChrootSessionMockRecorder) ExecWithContext(ctx, command any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecWithContext", reflect.TypeOf((*MockChrootSession)(nil).ExecWithContext), ctx, command)
}

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

// ExecWithOutput indicates an expected call of ExecWithOutput.
func (mr *MockChrootSessionMockRecorder) ExecWithOutput(command any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecWithOutput", reflect.TypeOf((*MockChrootSession)(nil).ExecWithOutput), command)
}

// ExecWithOutputAndContext mocks base method.
func (m *MockChrootSession) ExecWithOutputAndContext(ctx context.Context, command string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecWithOutputAndContext", ctx, command)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecWithOutputAndContext indicates an expected call of ExecWithOutputAndContext.
func (mr *MockChrootSessionMockRecorder) ExecWithOutputAndContext(ctx, command any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecWithOutputAndContext", reflect.TypeOf((*MockChrootSession)(nil).ExecWithOutputAndContext), ctx, command)
}

// MockChrootExecutor is a mock of ChrootExecutor interface.
type MockChrootExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockChrootExecutorMockRecorder
	isgomock struct{}
}

// MockChrootExecutorMockRecorder is the mock recorder for MockChrootExecutor.
type MockChrootExecutorMockRecorder struct {
	mock *MockChrootExecutor
}

// NewMockChrootExecutor creates a new mock instance.
func NewMockChrootExecutor(ctrl *gomock.Controller) *MockChrootExecutor {
	mock := &MockChrootExecutor{ctrl: ctrl}
	mock.recorder = &MockChrootExecutorMockRecorder{mock}
	return mock
}

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

// BeginSession mocks base method.
func (m *MockChrootExecutor) BeginSession(logPath, mountPoint string) (interfaces.ChrootSession, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeginSession", logPath, mountPoint)
	ret0, _ := ret[0].(interfaces.ChrootSession)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeginSession indicates an expected call of BeginSession.
func (mr *MockChrootExecutorMockRecorder) BeginSession(logPath, mountPoint any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginSession", reflect.TypeOf((*MockChrootExecutor)(nil).BeginSession), logPath, mountPoint)
}

// BeginSessionWithContext mocks base method.
func (m *MockChrootExecutor) BeginSessionWithContext(ctx context.Context, logPath, mountPoint string) (interfaces.ChrootSession, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeginSessionWithContext", ctx, logPath, mountPoint)
	ret0, _ := ret[0].(interfaces.ChrootSession)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeginSessionWithContext indicates an expected call of BeginSessionWithContext.
func (mr *MockChrootExecutorMockRecorder) BeginSessionWithContext(ctx, logPath, mountPoint any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginSessionWithContext", reflect.TypeOf((*MockChrootExecutor)(nil).BeginSessionWithContext), ctx, logPath, mountPoint)
}

// ChrootExec mocks base method.
func (m *MockChrootExecutor) ChrootExec(logPath, mountPoint, command string, args ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{logPath, mountPoint, command}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChrootExec", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChrootExec indicates an expected call of ChrootExec.
func (mr *MockChrootExecutorMockRecorder) ChrootExec(logPath, mountPoint, command any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{logPath, mountPoint, command}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExec", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExec), varargs...)
}

// ChrootExecWithContext mocks base method.
func (m *MockChrootExecutor) ChrootExecWithContext(ctx context.Context, logPath, mountPoint, command string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChrootExecWithContext", ctx, logPath, mountPoint, command)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChrootExecWithContext indicates an expected call of ChrootExecWithContext.
func (mr *MockChrootExecutorMockRecorder) ChrootExecWithContext(ctx, logPath, mountPoint, command any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExecWithContext", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExecWithContext), ctx, logPath, mountPoint, command)
}

// ChrootExecWithOutput mocks base method.
func (m *MockChrootExecutor) ChrootExecWithOutput(logPath, mountPoint, command string, args ...string) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{logPath, mountPoint, command}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChrootExecWithOutput", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChrootExecWithOutput indicates an expected call of ChrootExecWithOutput.
func (mr *MockChrootExecutorMockRecorder) ChrootExecWithOutput(logPath, mountPoint, command any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{logPath, mountPoint, command}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExecWithOutput", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExecWithOutput), varargs...)
}

// ChrootExecWithOutputAndContext mocks base method.
func (m *MockChrootExecutor) ChrootExecWithOutputAndContext(ctx context.Context, logPath, mountPoint, command string, args ...string) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, logPath, mountPoint, command}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChrootExecWithOutputAndContext", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChrootExecWithOutputAndContext indicates an expected call of ChrootExecWithOutputAndContext.
func (mr *MockChrootExecutorMockRecorder) ChrootExecWithOutputAndContext(ctx, logPath, mountPoint, command any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, logPath, mountPoint, command}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExecWithOutputAndContext", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExecWithOutputAndContext), varargs...)
}

// ChrootExecWithStdin mocks base method.
func (m *MockChrootExecutor) ChrootExecWithStdin(logPath, mountPoint, command, stdin string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChrootExecWithStdin", logPath, mountPoint, command, stdin)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChrootExecWithStdin indicates an expected call of ChrootExecWithStdin.
func (mr *MockChrootExecutorMockRecorder) ChrootExecWithStdin(logPath, mountPoint, command, stdin any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootExecWithStdin", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootExecWithStdin), logPath, mountPoint, command, stdin)
}

// ChrootPacman mocks base method.
func (m *MockChrootExecutor) ChrootPacman(logPath, mountPoint, operation string, packages ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{logPath, mountPoint, operation}
	for _, a := range packages {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChrootPacman", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChrootPacman indicates an expected call of ChrootPacman.
func (mr *MockChrootExecutorMockRecorder) ChrootPacman(logPath, mountPoint, operation any, packages ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{logPath, mountPoint, operation}, packages...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootPacman", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootPacman), varargs...)
}

// ChrootSystemctl mocks base method.
func (m *MockChrootExecutor) ChrootSystemctl(logPath, mountPoint, action, service string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChrootSystemctl", logPath, mountPoint, action, service)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChrootSystemctl indicates an expected call of ChrootSystemctl.
func (mr *MockChrootExecutorMockRecorder) ChrootSystemctl(logPath, mountPoint, action, service any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootSystemctl", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootSystemctl), logPath, mountPoint, action, service)
}

// DownloadAndInstallPackages mocks base method.
func (m *MockChrootExecutor) DownloadAndInstallPackages(logPath, chrootPath string, urls ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{logPath, chrootPath}
	for _, a := range urls {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DownloadAndInstallPackages", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DownloadAndInstallPackages indicates an expected call of DownloadAndInstallPackages.
func (mr *MockChrootExecutorMockRecorder) DownloadAndInstallPackages(logPath, chrootPath any, urls ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{logPath, chrootPath}, urls...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadAndInstallPackages", reflect.TypeOf((*MockChrootExecutor)(nil).DownloadAndInstallPackages), varargs...)
}

// MockHTTPClient is a mock of HTTPClient interface.
type MockHTTPClient struct {
	ctrl     *gomock.Controller
	recorder *MockHTTPClientMockRecorder
	isgomock struct{}
}

// MockHTTPClientMockRecorder is the mock recorder for MockHTTPClient.
type MockHTTPClientMockRecorder struct {
	mock *MockHTTPClient
}

// NewMockHTTPClient creates a new mock instance.
func NewMockHTTPClient(ctrl *gomock.Controller) *MockHTTPClient {
	mock := &MockHTTPClient{ctrl: ctrl}
	mock.recorder = &MockHTTPClientMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockHTTPClient) Get(url string) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", url)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockHTTPClientMockRecorder) Get(url any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHTTPClient)(nil).Get), url)
}

// MockConfigSaver is a mock of ConfigSaver interface.
type MockConfigSaver struct {
	ctrl     *gomock.Controller
	recorder *MockConfigSaverMockRecorder
	isgomock struct{}
}

// MockConfigSaverMockRecorder is the mock recorder for MockConfigSaver.
type MockConfigSaverMockRecorder struct {
	mock *MockConfigSaver
}

// NewMockConfigSaver creates a new mock instance.
func NewMockConfigSaver(ctrl *gomock.Controller) *MockConfigSaver {
	mock := &MockConfigSaver{ctrl: ctrl}
	mock.recorder = &MockConfigSaverMockRecorder{mock}
	return mock
}

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

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

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