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

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

import (
	encoding "encoding"
	reflect "reflect"

	config "github.com/aws/copilot-cli/internal/pkg/config"
	cloudformation "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
	gomock "github.com/golang/mock/gomock"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

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

// CreateJob indicates an expected call of CreateJob.
func (mr *MockStoreMockRecorder) CreateJob(job interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJob", reflect.TypeOf((*MockStore)(nil).CreateJob), job)
}

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

// CreateService indicates an expected call of CreateService.
func (mr *MockStoreMockRecorder) CreateService(service interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateService", reflect.TypeOf((*MockStore)(nil).CreateService), service)
}

// GetApplication mocks base method.
func (m *MockStore) GetApplication(appName string) (*config.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApplication", appName)
	ret0, _ := ret[0].(*config.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetApplication indicates an expected call of GetApplication.
func (mr *MockStoreMockRecorder) GetApplication(appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplication", reflect.TypeOf((*MockStore)(nil).GetApplication), appName)
}

// ListJobs mocks base method.
func (m *MockStore) ListJobs(appName string) ([]*config.Workload, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListJobs", appName)
	ret0, _ := ret[0].([]*config.Workload)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListJobs indicates an expected call of ListJobs.
func (mr *MockStoreMockRecorder) ListJobs(appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListJobs", reflect.TypeOf((*MockStore)(nil).ListJobs), appName)
}

// ListServices mocks base method.
func (m *MockStore) ListServices(appName string) ([]*config.Workload, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServices", appName)
	ret0, _ := ret[0].([]*config.Workload)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServices indicates an expected call of ListServices.
func (mr *MockStoreMockRecorder) ListServices(appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockStore)(nil).ListServices), appName)
}

// MockWorkloadAdder is a mock of WorkloadAdder interface.
type MockWorkloadAdder struct {
	ctrl     *gomock.Controller
	recorder *MockWorkloadAdderMockRecorder
}

// MockWorkloadAdderMockRecorder is the mock recorder for MockWorkloadAdder.
type MockWorkloadAdderMockRecorder struct {
	mock *MockWorkloadAdder
}

// NewMockWorkloadAdder creates a new mock instance.
func NewMockWorkloadAdder(ctrl *gomock.Controller) *MockWorkloadAdder {
	mock := &MockWorkloadAdder{ctrl: ctrl}
	mock.recorder = &MockWorkloadAdderMockRecorder{mock}
	return mock
}

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

// AddJobToApp mocks base method.
func (m *MockWorkloadAdder) AddJobToApp(app *config.Application, jobName string, opts ...cloudformation.AddWorkloadToAppOpt) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{app, jobName}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddJobToApp", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddJobToApp indicates an expected call of AddJobToApp.
func (mr *MockWorkloadAdderMockRecorder) AddJobToApp(app, jobName interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{app, jobName}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddJobToApp", reflect.TypeOf((*MockWorkloadAdder)(nil).AddJobToApp), varargs...)
}

// AddServiceToApp mocks base method.
func (m *MockWorkloadAdder) AddServiceToApp(app *config.Application, serviceName string, opts ...cloudformation.AddWorkloadToAppOpt) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{app, serviceName}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddServiceToApp", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddServiceToApp indicates an expected call of AddServiceToApp.
func (mr *MockWorkloadAdderMockRecorder) AddServiceToApp(app, serviceName interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{app, serviceName}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddServiceToApp", reflect.TypeOf((*MockWorkloadAdder)(nil).AddServiceToApp), varargs...)
}

// MockWorkspace is a mock of Workspace interface.
type MockWorkspace struct {
	ctrl     *gomock.Controller
	recorder *MockWorkspaceMockRecorder
}

// MockWorkspaceMockRecorder is the mock recorder for MockWorkspace.
type MockWorkspaceMockRecorder struct {
	mock *MockWorkspace
}

// NewMockWorkspace creates a new mock instance.
func NewMockWorkspace(ctrl *gomock.Controller) *MockWorkspace {
	mock := &MockWorkspace{ctrl: ctrl}
	mock.recorder = &MockWorkspaceMockRecorder{mock}
	return mock
}

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

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

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

// WriteJobManifest mocks base method.
func (m *MockWorkspace) WriteJobManifest(marshaler encoding.BinaryMarshaler, jobName string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteJobManifest", marshaler, jobName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteJobManifest indicates an expected call of WriteJobManifest.
func (mr *MockWorkspaceMockRecorder) WriteJobManifest(marshaler, jobName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteJobManifest", reflect.TypeOf((*MockWorkspace)(nil).WriteJobManifest), marshaler, jobName)
}

// WriteServiceManifest mocks base method.
func (m *MockWorkspace) WriteServiceManifest(marshaler encoding.BinaryMarshaler, serviceName string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteServiceManifest", marshaler, serviceName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteServiceManifest indicates an expected call of WriteServiceManifest.
func (mr *MockWorkspaceMockRecorder) WriteServiceManifest(marshaler, serviceName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteServiceManifest", reflect.TypeOf((*MockWorkspace)(nil).WriteServiceManifest), marshaler, serviceName)
}

// MockProg is a mock of Prog interface.
type MockProg struct {
	ctrl     *gomock.Controller
	recorder *MockProgMockRecorder
}

// MockProgMockRecorder is the mock recorder for MockProg.
type MockProgMockRecorder struct {
	mock *MockProg
}

// NewMockProg creates a new mock instance.
func NewMockProg(ctrl *gomock.Controller) *MockProg {
	mock := &MockProg{ctrl: ctrl}
	mock.recorder = &MockProgMockRecorder{mock}
	return mock
}

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

// Start mocks base method.
func (m *MockProg) Start(label string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", label)
}

// Start indicates an expected call of Start.
func (mr *MockProgMockRecorder) Start(label interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockProg)(nil).Start), label)
}

// Stop mocks base method.
func (m *MockProg) Stop(label string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop", label)
}

// Stop indicates an expected call of Stop.
func (mr *MockProgMockRecorder) Stop(label interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockProg)(nil).Stop), label)
}