// Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/template/template.go

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

import (
	fs "io/fs"
	reflect "reflect"

	template "github.com/aws/copilot-cli/internal/pkg/template"
	gomock "github.com/golang/mock/gomock"
)

// MockReader is a mock of Reader interface.
type MockReader struct {
	ctrl     *gomock.Controller
	recorder *MockReaderMockRecorder
}

// MockReaderMockRecorder is the mock recorder for MockReader.
type MockReaderMockRecorder struct {
	mock *MockReader
}

// NewMockReader creates a new mock instance.
func NewMockReader(ctrl *gomock.Controller) *MockReader {
	mock := &MockReader{ctrl: ctrl}
	mock.recorder = &MockReaderMockRecorder{mock}
	return mock
}

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

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

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

// MockParser is a mock of Parser interface.
type MockParser struct {
	ctrl     *gomock.Controller
	recorder *MockParserMockRecorder
}

// MockParserMockRecorder is the mock recorder for MockParser.
type MockParserMockRecorder struct {
	mock *MockParser
}

// NewMockParser creates a new mock instance.
func NewMockParser(ctrl *gomock.Controller) *MockParser {
	mock := &MockParser{ctrl: ctrl}
	mock.recorder = &MockParserMockRecorder{mock}
	return mock
}

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

// Parse mocks base method.
func (m *MockParser) Parse(path string, data interface{}, options ...template.ParseOption) (*template.Content, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{path, data}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Parse", varargs...)
	ret0, _ := ret[0].(*template.Content)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Parse indicates an expected call of Parse.
func (mr *MockParserMockRecorder) Parse(path, data interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{path, data}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockParser)(nil).Parse), varargs...)
}

// MockReadParser is a mock of ReadParser interface.
type MockReadParser struct {
	ctrl     *gomock.Controller
	recorder *MockReadParserMockRecorder
}

// MockReadParserMockRecorder is the mock recorder for MockReadParser.
type MockReadParserMockRecorder struct {
	mock *MockReadParser
}

// NewMockReadParser creates a new mock instance.
func NewMockReadParser(ctrl *gomock.Controller) *MockReadParser {
	mock := &MockReadParser{ctrl: ctrl}
	mock.recorder = &MockReadParserMockRecorder{mock}
	return mock
}

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

// Parse mocks base method.
func (m *MockReadParser) Parse(path string, data interface{}, options ...template.ParseOption) (*template.Content, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{path, data}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Parse", varargs...)
	ret0, _ := ret[0].(*template.Content)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Parse indicates an expected call of Parse.
func (mr *MockReadParserMockRecorder) Parse(path, data interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{path, data}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockReadParser)(nil).Parse), varargs...)
}

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

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

// MockosFS is a mock of osFS interface.
type MockosFS struct {
	ctrl     *gomock.Controller
	recorder *MockosFSMockRecorder
}

// MockosFSMockRecorder is the mock recorder for MockosFS.
type MockosFSMockRecorder struct {
	mock *MockosFS
}

// NewMockosFS creates a new mock instance.
func NewMockosFS(ctrl *gomock.Controller) *MockosFS {
	mock := &MockosFS{ctrl: ctrl}
	mock.recorder = &MockosFSMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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