@@ -3176,10 +3176,10 @@ func (m *MockpipelineStatusDescriber) EXPECT() *MockpipelineStatusDescriberMockR
 }
 
 // Describe mocks base method
-func (m *MockpipelineStatusDescriber) Describe() (*describe.PipelineStatusDesc, error) {
+func (m *MockpipelineStatusDescriber) Describe() (*describe.PipelineStatus, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Describe")
-	ret0, _ := ret[0].(*describe.PipelineStatusDesc)
+	ret0, _ := ret[0].(*describe.PipelineStatus)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
// Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/interfaces.go

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

import (
	encoding "encoding"
	cloudwatchlogs "github.com/aws/amazon-ecs-cli-v2/internal/pkg/aws/cloudwatchlogs"
	codepipeline "github.com/aws/amazon-ecs-cli-v2/internal/pkg/aws/codepipeline"
	ecr "github.com/aws/amazon-ecs-cli-v2/internal/pkg/aws/ecr"
	ecs "github.com/aws/amazon-ecs-cli-v2/internal/pkg/aws/ecs"
	config "github.com/aws/amazon-ecs-cli-v2/internal/pkg/config"
	deploy "github.com/aws/amazon-ecs-cli-v2/internal/pkg/deploy"
	stack "github.com/aws/amazon-ecs-cli-v2/internal/pkg/deploy/cloudformation/stack"
	describe "github.com/aws/amazon-ecs-cli-v2/internal/pkg/describe"
	command "github.com/aws/amazon-ecs-cli-v2/internal/pkg/term/command"
	workspace "github.com/aws/amazon-ecs-cli-v2/internal/pkg/workspace"
	session "github.com/aws/aws-sdk-go/aws/session"
	gomock "github.com/golang/mock/gomock"
	io "io"
	reflect "reflect"
)

// MockactionCommand is a mock of actionCommand interface
type MockactionCommand struct {
	ctrl     *gomock.Controller
	recorder *MockactionCommandMockRecorder
}

// MockactionCommandMockRecorder is the mock recorder for MockactionCommand
type MockactionCommandMockRecorder struct {
	mock *MockactionCommand
}

// NewMockactionCommand creates a new mock instance
func NewMockactionCommand(ctrl *gomock.Controller) *MockactionCommand {
	mock := &MockactionCommand{ctrl: ctrl}
	mock.recorder = &MockactionCommandMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockserviceStore is a mock of serviceStore interface
type MockserviceStore struct {
	ctrl     *gomock.Controller
	recorder *MockserviceStoreMockRecorder
}

// MockserviceStoreMockRecorder is the mock recorder for MockserviceStore
type MockserviceStoreMockRecorder struct {
	mock *MockserviceStore
}

// NewMockserviceStore creates a new mock instance
func NewMockserviceStore(ctrl *gomock.Controller) *MockserviceStore {
	mock := &MockserviceStore{ctrl: ctrl}
	mock.recorder = &MockserviceStoreMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockserviceCreator is a mock of serviceCreator interface
type MockserviceCreator struct {
	ctrl     *gomock.Controller
	recorder *MockserviceCreatorMockRecorder
}

// MockserviceCreatorMockRecorder is the mock recorder for MockserviceCreator
type MockserviceCreatorMockRecorder struct {
	mock *MockserviceCreator
}

// NewMockserviceCreator creates a new mock instance
func NewMockserviceCreator(ctrl *gomock.Controller) *MockserviceCreator {
	mock := &MockserviceCreator{ctrl: ctrl}
	mock.recorder = &MockserviceCreatorMockRecorder{mock}
	return mock
}

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

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

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

// MockserviceGetter is a mock of serviceGetter interface
type MockserviceGetter struct {
	ctrl     *gomock.Controller
	recorder *MockserviceGetterMockRecorder
}

// MockserviceGetterMockRecorder is the mock recorder for MockserviceGetter
type MockserviceGetterMockRecorder struct {
	mock *MockserviceGetter
}

// NewMockserviceGetter creates a new mock instance
func NewMockserviceGetter(ctrl *gomock.Controller) *MockserviceGetter {
	mock := &MockserviceGetter{ctrl: ctrl}
	mock.recorder = &MockserviceGetterMockRecorder{mock}
	return mock
}

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

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

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

// MockserviceLister is a mock of serviceLister interface
type MockserviceLister struct {
	ctrl     *gomock.Controller
	recorder *MockserviceListerMockRecorder
}

// MockserviceListerMockRecorder is the mock recorder for MockserviceLister
type MockserviceListerMockRecorder struct {
	mock *MockserviceLister
}

// NewMockserviceLister creates a new mock instance
func NewMockserviceLister(ctrl *gomock.Controller) *MockserviceLister {
	mock := &MockserviceLister{ctrl: ctrl}
	mock.recorder = &MockserviceListerMockRecorder{mock}
	return mock
}

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

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

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

// MockserviceDeleter is a mock of serviceDeleter interface
type MockserviceDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockserviceDeleterMockRecorder
}

// MockserviceDeleterMockRecorder is the mock recorder for MockserviceDeleter
type MockserviceDeleterMockRecorder struct {
	mock *MockserviceDeleter
}

// NewMockserviceDeleter creates a new mock instance
func NewMockserviceDeleter(ctrl *gomock.Controller) *MockserviceDeleter {
	mock := &MockserviceDeleter{ctrl: ctrl}
	mock.recorder = &MockserviceDeleterMockRecorder{mock}
	return mock
}

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

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

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

// MockapplicationStore is a mock of applicationStore interface
type MockapplicationStore struct {
	ctrl     *gomock.Controller
	recorder *MockapplicationStoreMockRecorder
}

// MockapplicationStoreMockRecorder is the mock recorder for MockapplicationStore
type MockapplicationStoreMockRecorder struct {
	mock *MockapplicationStore
}

// NewMockapplicationStore creates a new mock instance
func NewMockapplicationStore(ctrl *gomock.Controller) *MockapplicationStore {
	mock := &MockapplicationStore{ctrl: ctrl}
	mock.recorder = &MockapplicationStoreMockRecorder{mock}
	return mock
}

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

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

// CreateApplication indicates an expected call of CreateApplication
func (mr *MockapplicationStoreMockRecorder) CreateApplication(app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApplication", reflect.TypeOf((*MockapplicationStore)(nil).CreateApplication), app)
}

// GetApplication mocks base method
func (m *MockapplicationStore) 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 *MockapplicationStoreMockRecorder) GetApplication(appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplication", reflect.TypeOf((*MockapplicationStore)(nil).GetApplication), appName)
}

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

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

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

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

// MockapplicationCreator is a mock of applicationCreator interface
type MockapplicationCreator struct {
	ctrl     *gomock.Controller
	recorder *MockapplicationCreatorMockRecorder
}

// MockapplicationCreatorMockRecorder is the mock recorder for MockapplicationCreator
type MockapplicationCreatorMockRecorder struct {
	mock *MockapplicationCreator
}

// NewMockapplicationCreator creates a new mock instance
func NewMockapplicationCreator(ctrl *gomock.Controller) *MockapplicationCreator {
	mock := &MockapplicationCreator{ctrl: ctrl}
	mock.recorder = &MockapplicationCreatorMockRecorder{mock}
	return mock
}

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

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

// CreateApplication indicates an expected call of CreateApplication
func (mr *MockapplicationCreatorMockRecorder) CreateApplication(app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApplication", reflect.TypeOf((*MockapplicationCreator)(nil).CreateApplication), app)
}

// MockapplicationGetter is a mock of applicationGetter interface
type MockapplicationGetter struct {
	ctrl     *gomock.Controller
	recorder *MockapplicationGetterMockRecorder
}

// MockapplicationGetterMockRecorder is the mock recorder for MockapplicationGetter
type MockapplicationGetterMockRecorder struct {
	mock *MockapplicationGetter
}

// NewMockapplicationGetter creates a new mock instance
func NewMockapplicationGetter(ctrl *gomock.Controller) *MockapplicationGetter {
	mock := &MockapplicationGetter{ctrl: ctrl}
	mock.recorder = &MockapplicationGetterMockRecorder{mock}
	return mock
}

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

// GetApplication mocks base method
func (m *MockapplicationGetter) 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 *MockapplicationGetterMockRecorder) GetApplication(appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplication", reflect.TypeOf((*MockapplicationGetter)(nil).GetApplication), appName)
}

// MockapplicationLister is a mock of applicationLister interface
type MockapplicationLister struct {
	ctrl     *gomock.Controller
	recorder *MockapplicationListerMockRecorder
}

// MockapplicationListerMockRecorder is the mock recorder for MockapplicationLister
type MockapplicationListerMockRecorder struct {
	mock *MockapplicationLister
}

// NewMockapplicationLister creates a new mock instance
func NewMockapplicationLister(ctrl *gomock.Controller) *MockapplicationLister {
	mock := &MockapplicationLister{ctrl: ctrl}
	mock.recorder = &MockapplicationListerMockRecorder{mock}
	return mock
}

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

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

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

// MockapplicationDeleter is a mock of applicationDeleter interface
type MockapplicationDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockapplicationDeleterMockRecorder
}

// MockapplicationDeleterMockRecorder is the mock recorder for MockapplicationDeleter
type MockapplicationDeleterMockRecorder struct {
	mock *MockapplicationDeleter
}

// NewMockapplicationDeleter creates a new mock instance
func NewMockapplicationDeleter(ctrl *gomock.Controller) *MockapplicationDeleter {
	mock := &MockapplicationDeleter{ctrl: ctrl}
	mock.recorder = &MockapplicationDeleterMockRecorder{mock}
	return mock
}

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

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

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

// MockenvironmentStore is a mock of environmentStore interface
type MockenvironmentStore struct {
	ctrl     *gomock.Controller
	recorder *MockenvironmentStoreMockRecorder
}

// MockenvironmentStoreMockRecorder is the mock recorder for MockenvironmentStore
type MockenvironmentStoreMockRecorder struct {
	mock *MockenvironmentStore
}

// NewMockenvironmentStore creates a new mock instance
func NewMockenvironmentStore(ctrl *gomock.Controller) *MockenvironmentStore {
	mock := &MockenvironmentStore{ctrl: ctrl}
	mock.recorder = &MockenvironmentStoreMockRecorder{mock}
	return mock
}

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

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

// CreateEnvironment indicates an expected call of CreateEnvironment
func (mr *MockenvironmentStoreMockRecorder) CreateEnvironment(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEnvironment", reflect.TypeOf((*MockenvironmentStore)(nil).CreateEnvironment), env)
}

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

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

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

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

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

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

// MockenvironmentCreator is a mock of environmentCreator interface
type MockenvironmentCreator struct {
	ctrl     *gomock.Controller
	recorder *MockenvironmentCreatorMockRecorder
}

// MockenvironmentCreatorMockRecorder is the mock recorder for MockenvironmentCreator
type MockenvironmentCreatorMockRecorder struct {
	mock *MockenvironmentCreator
}

// NewMockenvironmentCreator creates a new mock instance
func NewMockenvironmentCreator(ctrl *gomock.Controller) *MockenvironmentCreator {
	mock := &MockenvironmentCreator{ctrl: ctrl}
	mock.recorder = &MockenvironmentCreatorMockRecorder{mock}
	return mock
}

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

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

// CreateEnvironment indicates an expected call of CreateEnvironment
func (mr *MockenvironmentCreatorMockRecorder) CreateEnvironment(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEnvironment", reflect.TypeOf((*MockenvironmentCreator)(nil).CreateEnvironment), env)
}

// MockenvironmentGetter is a mock of environmentGetter interface
type MockenvironmentGetter struct {
	ctrl     *gomock.Controller
	recorder *MockenvironmentGetterMockRecorder
}

// MockenvironmentGetterMockRecorder is the mock recorder for MockenvironmentGetter
type MockenvironmentGetterMockRecorder struct {
	mock *MockenvironmentGetter
}

// NewMockenvironmentGetter creates a new mock instance
func NewMockenvironmentGetter(ctrl *gomock.Controller) *MockenvironmentGetter {
	mock := &MockenvironmentGetter{ctrl: ctrl}
	mock.recorder = &MockenvironmentGetterMockRecorder{mock}
	return mock
}

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

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

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

// MockenvironmentLister is a mock of environmentLister interface
type MockenvironmentLister struct {
	ctrl     *gomock.Controller
	recorder *MockenvironmentListerMockRecorder
}

// MockenvironmentListerMockRecorder is the mock recorder for MockenvironmentLister
type MockenvironmentListerMockRecorder struct {
	mock *MockenvironmentLister
}

// NewMockenvironmentLister creates a new mock instance
func NewMockenvironmentLister(ctrl *gomock.Controller) *MockenvironmentLister {
	mock := &MockenvironmentLister{ctrl: ctrl}
	mock.recorder = &MockenvironmentListerMockRecorder{mock}
	return mock
}

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

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

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

// MockenvironmentDeleter is a mock of environmentDeleter interface
type MockenvironmentDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockenvironmentDeleterMockRecorder
}

// MockenvironmentDeleterMockRecorder is the mock recorder for MockenvironmentDeleter
type MockenvironmentDeleterMockRecorder struct {
	mock *MockenvironmentDeleter
}

// NewMockenvironmentDeleter creates a new mock instance
func NewMockenvironmentDeleter(ctrl *gomock.Controller) *MockenvironmentDeleter {
	mock := &MockenvironmentDeleter{ctrl: ctrl}
	mock.recorder = &MockenvironmentDeleterMockRecorder{mock}
	return mock
}

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

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

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

// 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
}

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

// CreateApplication indicates an expected call of CreateApplication
func (mr *MockstoreMockRecorder) CreateApplication(app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApplication", reflect.TypeOf((*Mockstore)(nil).CreateApplication), app)
}

// 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)
}

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

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

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

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

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

// CreateEnvironment indicates an expected call of CreateEnvironment
func (mr *MockstoreMockRecorder) CreateEnvironment(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEnvironment", reflect.TypeOf((*Mockstore)(nil).CreateEnvironment), env)
}

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

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

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

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

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

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

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

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

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

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

// ListServices mocks base method
func (m *Mockstore) ListServices(appName string) ([]*config.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServices", appName)
	ret0, _ := ret[0].([]*config.Service)
	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)
}

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

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

// MocksecretsManager is a mock of secretsManager interface
type MocksecretsManager struct {
	ctrl     *gomock.Controller
	recorder *MocksecretsManagerMockRecorder
}

// MocksecretsManagerMockRecorder is the mock recorder for MocksecretsManager
type MocksecretsManagerMockRecorder struct {
	mock *MocksecretsManager
}

// NewMocksecretsManager creates a new mock instance
func NewMocksecretsManager(ctrl *gomock.Controller) *MocksecretsManager {
	mock := &MocksecretsManager{ctrl: ctrl}
	mock.recorder = &MocksecretsManagerMockRecorder{mock}
	return mock
}

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

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

// CreateSecret indicates an expected call of CreateSecret
func (mr *MocksecretsManagerMockRecorder) CreateSecret(secretName, secretString interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MocksecretsManager)(nil).CreateSecret), secretName, secretString)
}

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

// DeleteSecret indicates an expected call of DeleteSecret
func (mr *MocksecretsManagerMockRecorder) DeleteSecret(secretName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MocksecretsManager)(nil).DeleteSecret), secretName)
}

// MocksecretCreator is a mock of secretCreator interface
type MocksecretCreator struct {
	ctrl     *gomock.Controller
	recorder *MocksecretCreatorMockRecorder
}

// MocksecretCreatorMockRecorder is the mock recorder for MocksecretCreator
type MocksecretCreatorMockRecorder struct {
	mock *MocksecretCreator
}

// NewMocksecretCreator creates a new mock instance
func NewMocksecretCreator(ctrl *gomock.Controller) *MocksecretCreator {
	mock := &MocksecretCreator{ctrl: ctrl}
	mock.recorder = &MocksecretCreatorMockRecorder{mock}
	return mock
}

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

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

// CreateSecret indicates an expected call of CreateSecret
func (mr *MocksecretCreatorMockRecorder) CreateSecret(secretName, secretString interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MocksecretCreator)(nil).CreateSecret), secretName, secretString)
}

// MocksecretDeleter is a mock of secretDeleter interface
type MocksecretDeleter struct {
	ctrl     *gomock.Controller
	recorder *MocksecretDeleterMockRecorder
}

// MocksecretDeleterMockRecorder is the mock recorder for MocksecretDeleter
type MocksecretDeleterMockRecorder struct {
	mock *MocksecretDeleter
}

// NewMocksecretDeleter creates a new mock instance
func NewMocksecretDeleter(ctrl *gomock.Controller) *MocksecretDeleter {
	mock := &MocksecretDeleter{ctrl: ctrl}
	mock.recorder = &MocksecretDeleterMockRecorder{mock}
	return mock
}

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

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

// DeleteSecret indicates an expected call of DeleteSecret
func (mr *MocksecretDeleterMockRecorder) DeleteSecret(secretName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MocksecretDeleter)(nil).DeleteSecret), secretName)
}

// MockecrService is a mock of ecrService interface
type MockecrService struct {
	ctrl     *gomock.Controller
	recorder *MockecrServiceMockRecorder
}

// MockecrServiceMockRecorder is the mock recorder for MockecrService
type MockecrServiceMockRecorder struct {
	mock *MockecrService
}

// NewMockecrService creates a new mock instance
func NewMockecrService(ctrl *gomock.Controller) *MockecrService {
	mock := &MockecrService{ctrl: ctrl}
	mock.recorder = &MockecrServiceMockRecorder{mock}
	return mock
}

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

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

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

// GetECRAuth mocks base method
func (m *MockecrService) GetECRAuth() (ecr.Auth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetECRAuth")
	ret0, _ := ret[0].(ecr.Auth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockcwlogService is a mock of cwlogService interface
type MockcwlogService struct {
	ctrl     *gomock.Controller
	recorder *MockcwlogServiceMockRecorder
}

// MockcwlogServiceMockRecorder is the mock recorder for MockcwlogService
type MockcwlogServiceMockRecorder struct {
	mock *MockcwlogService
}

// NewMockcwlogService creates a new mock instance
func NewMockcwlogService(ctrl *gomock.Controller) *MockcwlogService {
	mock := &MockcwlogService{ctrl: ctrl}
	mock.recorder = &MockcwlogServiceMockRecorder{mock}
	return mock
}

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

// TaskLogEvents mocks base method
func (m *MockcwlogService) TaskLogEvents(logGroupName string, streamLastEventTime map[string]int64, opts ...cloudwatchlogs.GetLogEventsOpts) (*cloudwatchlogs.LogEventsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{logGroupName, streamLastEventTime}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TaskLogEvents", varargs...)
	ret0, _ := ret[0].(*cloudwatchlogs.LogEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskLogEvents indicates an expected call of TaskLogEvents
func (mr *MockcwlogServiceMockRecorder) TaskLogEvents(logGroupName, streamLastEventTime interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{logGroupName, streamLastEventTime}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskLogEvents", reflect.TypeOf((*MockcwlogService)(nil).TaskLogEvents), varargs...)
}

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

// LogGroupExists indicates an expected call of LogGroupExists
func (mr *MockcwlogServiceMockRecorder) LogGroupExists(logGroupName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogGroupExists", reflect.TypeOf((*MockcwlogService)(nil).LogGroupExists), logGroupName)
}

// Mocktemplater is a mock of templater interface
type Mocktemplater struct {
	ctrl     *gomock.Controller
	recorder *MocktemplaterMockRecorder
}

// MocktemplaterMockRecorder is the mock recorder for Mocktemplater
type MocktemplaterMockRecorder struct {
	mock *Mocktemplater
}

// NewMocktemplater creates a new mock instance
func NewMocktemplater(ctrl *gomock.Controller) *Mocktemplater {
	mock := &Mocktemplater{ctrl: ctrl}
	mock.recorder = &MocktemplaterMockRecorder{mock}
	return mock
}

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

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

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

// MockstackSerializer is a mock of stackSerializer interface
type MockstackSerializer struct {
	ctrl     *gomock.Controller
	recorder *MockstackSerializerMockRecorder
}

// MockstackSerializerMockRecorder is the mock recorder for MockstackSerializer
type MockstackSerializerMockRecorder struct {
	mock *MockstackSerializer
}

// NewMockstackSerializer creates a new mock instance
func NewMockstackSerializer(ctrl *gomock.Controller) *MockstackSerializer {
	mock := &MockstackSerializer{ctrl: ctrl}
	mock.recorder = &MockstackSerializerMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockdockerService is a mock of dockerService interface
type MockdockerService struct {
	ctrl     *gomock.Controller
	recorder *MockdockerServiceMockRecorder
}

// MockdockerServiceMockRecorder is the mock recorder for MockdockerService
type MockdockerServiceMockRecorder struct {
	mock *MockdockerService
}

// NewMockdockerService creates a new mock instance
func NewMockdockerService(ctrl *gomock.Controller) *MockdockerService {
	mock := &MockdockerService{ctrl: ctrl}
	mock.recorder = &MockdockerServiceMockRecorder{mock}
	return mock
}

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

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

// Build indicates an expected call of Build
func (mr *MockdockerServiceMockRecorder) Build(uri, tag, path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockdockerService)(nil).Build), uri, tag, path)
}

// Login mocks base method
func (m *MockdockerService) Login(uri, username, password string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Login", uri, username, password)
	ret0, _ := ret[0].(error)
	return ret0
}

// Login indicates an expected call of Login
func (mr *MockdockerServiceMockRecorder) Login(uri, username, password interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockdockerService)(nil).Login), uri, username, password)
}

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

// Push indicates an expected call of Push
func (mr *MockdockerServiceMockRecorder) Push(uri, tag interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockdockerService)(nil).Push), uri, tag)
}

// Mockrunner is a mock of runner interface
type Mockrunner struct {
	ctrl     *gomock.Controller
	recorder *MockrunnerMockRecorder
}

// MockrunnerMockRecorder is the mock recorder for Mockrunner
type MockrunnerMockRecorder struct {
	mock *Mockrunner
}

// NewMockrunner creates a new mock instance
func NewMockrunner(ctrl *gomock.Controller) *Mockrunner {
	mock := &Mockrunner{ctrl: ctrl}
	mock.recorder = &MockrunnerMockRecorder{mock}
	return mock
}

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

// Run mocks base method
func (m *Mockrunner) Run(name string, args []string, options ...command.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{name, args}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Run", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run
func (mr *MockrunnerMockRecorder) Run(name, args interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name, args}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*Mockrunner)(nil).Run), varargs...)
}

// MockdefaultSessionProvider is a mock of defaultSessionProvider interface
type MockdefaultSessionProvider struct {
	ctrl     *gomock.Controller
	recorder *MockdefaultSessionProviderMockRecorder
}

// MockdefaultSessionProviderMockRecorder is the mock recorder for MockdefaultSessionProvider
type MockdefaultSessionProviderMockRecorder struct {
	mock *MockdefaultSessionProvider
}

// NewMockdefaultSessionProvider creates a new mock instance
func NewMockdefaultSessionProvider(ctrl *gomock.Controller) *MockdefaultSessionProvider {
	mock := &MockdefaultSessionProvider{ctrl: ctrl}
	mock.recorder = &MockdefaultSessionProviderMockRecorder{mock}
	return mock
}

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

// Default mocks base method
func (m *MockdefaultSessionProvider) Default() (*session.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Default")
	ret0, _ := ret[0].(*session.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockregionalSessionProvider is a mock of regionalSessionProvider interface
type MockregionalSessionProvider struct {
	ctrl     *gomock.Controller
	recorder *MockregionalSessionProviderMockRecorder
}

// MockregionalSessionProviderMockRecorder is the mock recorder for MockregionalSessionProvider
type MockregionalSessionProviderMockRecorder struct {
	mock *MockregionalSessionProvider
}

// NewMockregionalSessionProvider creates a new mock instance
func NewMockregionalSessionProvider(ctrl *gomock.Controller) *MockregionalSessionProvider {
	mock := &MockregionalSessionProvider{ctrl: ctrl}
	mock.recorder = &MockregionalSessionProviderMockRecorder{mock}
	return mock
}

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

// DefaultWithRegion mocks base method
func (m *MockregionalSessionProvider) DefaultWithRegion(region string) (*session.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DefaultWithRegion", region)
	ret0, _ := ret[0].(*session.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DefaultWithRegion indicates an expected call of DefaultWithRegion
func (mr *MockregionalSessionProviderMockRecorder) DefaultWithRegion(region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultWithRegion", reflect.TypeOf((*MockregionalSessionProvider)(nil).DefaultWithRegion), region)
}

// MocksessionFromRoleProvider is a mock of sessionFromRoleProvider interface
type MocksessionFromRoleProvider struct {
	ctrl     *gomock.Controller
	recorder *MocksessionFromRoleProviderMockRecorder
}

// MocksessionFromRoleProviderMockRecorder is the mock recorder for MocksessionFromRoleProvider
type MocksessionFromRoleProviderMockRecorder struct {
	mock *MocksessionFromRoleProvider
}

// NewMocksessionFromRoleProvider creates a new mock instance
func NewMocksessionFromRoleProvider(ctrl *gomock.Controller) *MocksessionFromRoleProvider {
	mock := &MocksessionFromRoleProvider{ctrl: ctrl}
	mock.recorder = &MocksessionFromRoleProviderMockRecorder{mock}
	return mock
}

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

// FromRole mocks base method
func (m *MocksessionFromRoleProvider) FromRole(roleARN, region string) (*session.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FromRole", roleARN, region)
	ret0, _ := ret[0].(*session.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FromRole indicates an expected call of FromRole
func (mr *MocksessionFromRoleProviderMockRecorder) FromRole(roleARN, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromRole", reflect.TypeOf((*MocksessionFromRoleProvider)(nil).FromRole), roleARN, region)
}

// MockprofileNames is a mock of profileNames interface
type MockprofileNames struct {
	ctrl     *gomock.Controller
	recorder *MockprofileNamesMockRecorder
}

// MockprofileNamesMockRecorder is the mock recorder for MockprofileNames
type MockprofileNamesMockRecorder struct {
	mock *MockprofileNames
}

// NewMockprofileNames creates a new mock instance
func NewMockprofileNames(ctrl *gomock.Controller) *MockprofileNames {
	mock := &MockprofileNames{ctrl: ctrl}
	mock.recorder = &MockprofileNamesMockRecorder{mock}
	return mock
}

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

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

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

// MocksessionProvider is a mock of sessionProvider interface
type MocksessionProvider struct {
	ctrl     *gomock.Controller
	recorder *MocksessionProviderMockRecorder
}

// MocksessionProviderMockRecorder is the mock recorder for MocksessionProvider
type MocksessionProviderMockRecorder struct {
	mock *MocksessionProvider
}

// NewMocksessionProvider creates a new mock instance
func NewMocksessionProvider(ctrl *gomock.Controller) *MocksessionProvider {
	mock := &MocksessionProvider{ctrl: ctrl}
	mock.recorder = &MocksessionProviderMockRecorder{mock}
	return mock
}

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

// Default mocks base method
func (m *MocksessionProvider) Default() (*session.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Default")
	ret0, _ := ret[0].(*session.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DefaultWithRegion mocks base method
func (m *MocksessionProvider) DefaultWithRegion(region string) (*session.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DefaultWithRegion", region)
	ret0, _ := ret[0].(*session.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DefaultWithRegion indicates an expected call of DefaultWithRegion
func (mr *MocksessionProviderMockRecorder) DefaultWithRegion(region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultWithRegion", reflect.TypeOf((*MocksessionProvider)(nil).DefaultWithRegion), region)
}

// FromRole mocks base method
func (m *MocksessionProvider) FromRole(roleARN, region string) (*session.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FromRole", roleARN, region)
	ret0, _ := ret[0].(*session.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FromRole indicates an expected call of FromRole
func (mr *MocksessionProviderMockRecorder) FromRole(roleARN, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromRole", reflect.TypeOf((*MocksessionProvider)(nil).FromRole), roleARN, region)
}

// Mockdescriber is a mock of describer interface
type Mockdescriber struct {
	ctrl     *gomock.Controller
	recorder *MockdescriberMockRecorder
}

// MockdescriberMockRecorder is the mock recorder for Mockdescriber
type MockdescriberMockRecorder struct {
	mock *Mockdescriber
}

// NewMockdescriber creates a new mock instance
func NewMockdescriber(ctrl *gomock.Controller) *Mockdescriber {
	mock := &Mockdescriber{ctrl: ctrl}
	mock.recorder = &MockdescriberMockRecorder{mock}
	return mock
}

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

// Describe mocks base method
func (m *Mockdescriber) Describe() (describe.HumanJSONStringer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Describe")
	ret0, _ := ret[0].(describe.HumanJSONStringer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockworkspaceDeleter is a mock of workspaceDeleter interface
type MockworkspaceDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockworkspaceDeleterMockRecorder
}

// MockworkspaceDeleterMockRecorder is the mock recorder for MockworkspaceDeleter
type MockworkspaceDeleterMockRecorder struct {
	mock *MockworkspaceDeleter
}

// NewMockworkspaceDeleter creates a new mock instance
func NewMockworkspaceDeleter(ctrl *gomock.Controller) *MockworkspaceDeleter {
	mock := &MockworkspaceDeleter{ctrl: ctrl}
	mock.recorder = &MockworkspaceDeleterMockRecorder{mock}
	return mock
}

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

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

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

// MocksvcManifestReader is a mock of svcManifestReader interface
type MocksvcManifestReader struct {
	ctrl     *gomock.Controller
	recorder *MocksvcManifestReaderMockRecorder
}

// MocksvcManifestReaderMockRecorder is the mock recorder for MocksvcManifestReader
type MocksvcManifestReaderMockRecorder struct {
	mock *MocksvcManifestReader
}

// NewMocksvcManifestReader creates a new mock instance
func NewMocksvcManifestReader(ctrl *gomock.Controller) *MocksvcManifestReader {
	mock := &MocksvcManifestReader{ctrl: ctrl}
	mock.recorder = &MocksvcManifestReaderMockRecorder{mock}
	return mock
}

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

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

// ReadServiceManifest indicates an expected call of ReadServiceManifest
func (mr *MocksvcManifestReaderMockRecorder) ReadServiceManifest(svcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadServiceManifest", reflect.TypeOf((*MocksvcManifestReader)(nil).ReadServiceManifest), svcName)
}

// MocksvcManifestWriter is a mock of svcManifestWriter interface
type MocksvcManifestWriter struct {
	ctrl     *gomock.Controller
	recorder *MocksvcManifestWriterMockRecorder
}

// MocksvcManifestWriterMockRecorder is the mock recorder for MocksvcManifestWriter
type MocksvcManifestWriterMockRecorder struct {
	mock *MocksvcManifestWriter
}

// NewMocksvcManifestWriter creates a new mock instance
func NewMocksvcManifestWriter(ctrl *gomock.Controller) *MocksvcManifestWriter {
	mock := &MocksvcManifestWriter{ctrl: ctrl}
	mock.recorder = &MocksvcManifestWriterMockRecorder{mock}
	return mock
}

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

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

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

// MockwsPipelineManifestReader is a mock of wsPipelineManifestReader interface
type MockwsPipelineManifestReader struct {
	ctrl     *gomock.Controller
	recorder *MockwsPipelineManifestReaderMockRecorder
}

// MockwsPipelineManifestReaderMockRecorder is the mock recorder for MockwsPipelineManifestReader
type MockwsPipelineManifestReaderMockRecorder struct {
	mock *MockwsPipelineManifestReader
}

// NewMockwsPipelineManifestReader creates a new mock instance
func NewMockwsPipelineManifestReader(ctrl *gomock.Controller) *MockwsPipelineManifestReader {
	mock := &MockwsPipelineManifestReader{ctrl: ctrl}
	mock.recorder = &MockwsPipelineManifestReaderMockRecorder{mock}
	return mock
}

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

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

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

// MockwsPipelineWriter is a mock of wsPipelineWriter interface
type MockwsPipelineWriter struct {
	ctrl     *gomock.Controller
	recorder *MockwsPipelineWriterMockRecorder
}

// MockwsPipelineWriterMockRecorder is the mock recorder for MockwsPipelineWriter
type MockwsPipelineWriterMockRecorder struct {
	mock *MockwsPipelineWriter
}

// NewMockwsPipelineWriter creates a new mock instance
func NewMockwsPipelineWriter(ctrl *gomock.Controller) *MockwsPipelineWriter {
	mock := &MockwsPipelineWriter{ctrl: ctrl}
	mock.recorder = &MockwsPipelineWriterMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockwsSvcDeleter is a mock of wsSvcDeleter interface
type MockwsSvcDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockwsSvcDeleterMockRecorder
}

// MockwsSvcDeleterMockRecorder is the mock recorder for MockwsSvcDeleter
type MockwsSvcDeleterMockRecorder struct {
	mock *MockwsSvcDeleter
}

// NewMockwsSvcDeleter creates a new mock instance
func NewMockwsSvcDeleter(ctrl *gomock.Controller) *MockwsSvcDeleter {
	mock := &MockwsSvcDeleter{ctrl: ctrl}
	mock.recorder = &MockwsSvcDeleterMockRecorder{mock}
	return mock
}

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

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

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

// MockwsServiceLister is a mock of wsServiceLister interface
type MockwsServiceLister struct {
	ctrl     *gomock.Controller
	recorder *MockwsServiceListerMockRecorder
}

// MockwsServiceListerMockRecorder is the mock recorder for MockwsServiceLister
type MockwsServiceListerMockRecorder struct {
	mock *MockwsServiceLister
}

// NewMockwsServiceLister creates a new mock instance
func NewMockwsServiceLister(ctrl *gomock.Controller) *MockwsServiceLister {
	mock := &MockwsServiceLister{ctrl: ctrl}
	mock.recorder = &MockwsServiceListerMockRecorder{mock}
	return mock
}

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

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

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

// MockwsSvcReader is a mock of wsSvcReader interface
type MockwsSvcReader struct {
	ctrl     *gomock.Controller
	recorder *MockwsSvcReaderMockRecorder
}

// MockwsSvcReaderMockRecorder is the mock recorder for MockwsSvcReader
type MockwsSvcReaderMockRecorder struct {
	mock *MockwsSvcReader
}

// NewMockwsSvcReader creates a new mock instance
func NewMockwsSvcReader(ctrl *gomock.Controller) *MockwsSvcReader {
	mock := &MockwsSvcReader{ctrl: ctrl}
	mock.recorder = &MockwsSvcReaderMockRecorder{mock}
	return mock
}

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

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

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

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

// ReadServiceManifest indicates an expected call of ReadServiceManifest
func (mr *MockwsSvcReaderMockRecorder) ReadServiceManifest(svcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadServiceManifest", reflect.TypeOf((*MockwsSvcReader)(nil).ReadServiceManifest), svcName)
}

// MockwsPipelineDeleter is a mock of wsPipelineDeleter interface
type MockwsPipelineDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockwsPipelineDeleterMockRecorder
}

// MockwsPipelineDeleterMockRecorder is the mock recorder for MockwsPipelineDeleter
type MockwsPipelineDeleterMockRecorder struct {
	mock *MockwsPipelineDeleter
}

// NewMockwsPipelineDeleter creates a new mock instance
func NewMockwsPipelineDeleter(ctrl *gomock.Controller) *MockwsPipelineDeleter {
	mock := &MockwsPipelineDeleter{ctrl: ctrl}
	mock.recorder = &MockwsPipelineDeleterMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockwsPipelineReader is a mock of wsPipelineReader interface
type MockwsPipelineReader struct {
	ctrl     *gomock.Controller
	recorder *MockwsPipelineReaderMockRecorder
}

// MockwsPipelineReaderMockRecorder is the mock recorder for MockwsPipelineReader
type MockwsPipelineReaderMockRecorder struct {
	mock *MockwsPipelineReader
}

// NewMockwsPipelineReader creates a new mock instance
func NewMockwsPipelineReader(ctrl *gomock.Controller) *MockwsPipelineReader {
	mock := &MockwsPipelineReader{ctrl: ctrl}
	mock.recorder = &MockwsPipelineReaderMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockwsAppManager is a mock of wsAppManager interface
type MockwsAppManager struct {
	ctrl     *gomock.Controller
	recorder *MockwsAppManagerMockRecorder
}

// MockwsAppManagerMockRecorder is the mock recorder for MockwsAppManager
type MockwsAppManagerMockRecorder struct {
	mock *MockwsAppManager
}

// NewMockwsAppManager creates a new mock instance
func NewMockwsAppManager(ctrl *gomock.Controller) *MockwsAppManager {
	mock := &MockwsAppManager{ctrl: ctrl}
	mock.recorder = &MockwsAppManagerMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockartifactUploader is a mock of artifactUploader interface
type MockartifactUploader struct {
	ctrl     *gomock.Controller
	recorder *MockartifactUploaderMockRecorder
}

// MockartifactUploaderMockRecorder is the mock recorder for MockartifactUploader
type MockartifactUploaderMockRecorder struct {
	mock *MockartifactUploader
}

// NewMockartifactUploader creates a new mock instance
func NewMockartifactUploader(ctrl *gomock.Controller) *MockartifactUploader {
	mock := &MockartifactUploader{ctrl: ctrl}
	mock.recorder = &MockartifactUploaderMockRecorder{mock}
	return mock
}

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

// PutArtifact mocks base method
func (m *MockartifactUploader) PutArtifact(bucket, fileName string, data io.Reader) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutArtifact", bucket, fileName, data)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutArtifact indicates an expected call of PutArtifact
func (mr *MockartifactUploaderMockRecorder) PutArtifact(bucket, fileName, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutArtifact", reflect.TypeOf((*MockartifactUploader)(nil).PutArtifact), bucket, fileName, data)
}

// MockbucketEmptier is a mock of bucketEmptier interface
type MockbucketEmptier struct {
	ctrl     *gomock.Controller
	recorder *MockbucketEmptierMockRecorder
}

// MockbucketEmptierMockRecorder is the mock recorder for MockbucketEmptier
type MockbucketEmptierMockRecorder struct {
	mock *MockbucketEmptier
}

// NewMockbucketEmptier creates a new mock instance
func NewMockbucketEmptier(ctrl *gomock.Controller) *MockbucketEmptier {
	mock := &MockbucketEmptier{ctrl: ctrl}
	mock.recorder = &MockbucketEmptierMockRecorder{mock}
	return mock
}

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

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

// EmptyBucket indicates an expected call of EmptyBucket
func (mr *MockbucketEmptierMockRecorder) EmptyBucket(bucket interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmptyBucket", reflect.TypeOf((*MockbucketEmptier)(nil).EmptyBucket), bucket)
}

// MockenvironmentDeployer is a mock of environmentDeployer interface
type MockenvironmentDeployer struct {
	ctrl     *gomock.Controller
	recorder *MockenvironmentDeployerMockRecorder
}

// MockenvironmentDeployerMockRecorder is the mock recorder for MockenvironmentDeployer
type MockenvironmentDeployerMockRecorder struct {
	mock *MockenvironmentDeployer
}

// NewMockenvironmentDeployer creates a new mock instance
func NewMockenvironmentDeployer(ctrl *gomock.Controller) *MockenvironmentDeployer {
	mock := &MockenvironmentDeployer{ctrl: ctrl}
	mock.recorder = &MockenvironmentDeployerMockRecorder{mock}
	return mock
}

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

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

// DeployEnvironment indicates an expected call of DeployEnvironment
func (mr *MockenvironmentDeployerMockRecorder) DeployEnvironment(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployEnvironment", reflect.TypeOf((*MockenvironmentDeployer)(nil).DeployEnvironment), env)
}

// StreamEnvironmentCreation mocks base method
func (m *MockenvironmentDeployer) StreamEnvironmentCreation(env *deploy.CreateEnvironmentInput) (<-chan []deploy.ResourceEvent, <-chan deploy.CreateEnvironmentResponse) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamEnvironmentCreation", env)
	ret0, _ := ret[0].(<-chan []deploy.ResourceEvent)
	ret1, _ := ret[1].(<-chan deploy.CreateEnvironmentResponse)
	return ret0, ret1
}

// StreamEnvironmentCreation indicates an expected call of StreamEnvironmentCreation
func (mr *MockenvironmentDeployerMockRecorder) StreamEnvironmentCreation(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamEnvironmentCreation", reflect.TypeOf((*MockenvironmentDeployer)(nil).StreamEnvironmentCreation), env)
}

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

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

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

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

// MocksvcDeleter is a mock of svcDeleter interface
type MocksvcDeleter struct {
	ctrl     *gomock.Controller
	recorder *MocksvcDeleterMockRecorder
}

// MocksvcDeleterMockRecorder is the mock recorder for MocksvcDeleter
type MocksvcDeleterMockRecorder struct {
	mock *MocksvcDeleter
}

// NewMocksvcDeleter creates a new mock instance
func NewMocksvcDeleter(ctrl *gomock.Controller) *MocksvcDeleter {
	mock := &MocksvcDeleter{ctrl: ctrl}
	mock.recorder = &MocksvcDeleterMockRecorder{mock}
	return mock
}

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

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

// DeleteService indicates an expected call of DeleteService
func (mr *MocksvcDeleterMockRecorder) DeleteService(in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MocksvcDeleter)(nil).DeleteService), in)
}

// MocksvcRemoverFromApp is a mock of svcRemoverFromApp interface
type MocksvcRemoverFromApp struct {
	ctrl     *gomock.Controller
	recorder *MocksvcRemoverFromAppMockRecorder
}

// MocksvcRemoverFromAppMockRecorder is the mock recorder for MocksvcRemoverFromApp
type MocksvcRemoverFromAppMockRecorder struct {
	mock *MocksvcRemoverFromApp
}

// NewMocksvcRemoverFromApp creates a new mock instance
func NewMocksvcRemoverFromApp(ctrl *gomock.Controller) *MocksvcRemoverFromApp {
	mock := &MocksvcRemoverFromApp{ctrl: ctrl}
	mock.recorder = &MocksvcRemoverFromAppMockRecorder{mock}
	return mock
}

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

// RemoveServiceFromApp mocks base method
func (m *MocksvcRemoverFromApp) RemoveServiceFromApp(app *config.Application, svcName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveServiceFromApp", app, svcName)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveServiceFromApp indicates an expected call of RemoveServiceFromApp
func (mr *MocksvcRemoverFromAppMockRecorder) RemoveServiceFromApp(app, svcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveServiceFromApp", reflect.TypeOf((*MocksvcRemoverFromApp)(nil).RemoveServiceFromApp), app, svcName)
}

// MockimageRemover is a mock of imageRemover interface
type MockimageRemover struct {
	ctrl     *gomock.Controller
	recorder *MockimageRemoverMockRecorder
}

// MockimageRemoverMockRecorder is the mock recorder for MockimageRemover
type MockimageRemoverMockRecorder struct {
	mock *MockimageRemover
}

// NewMockimageRemover creates a new mock instance
func NewMockimageRemover(ctrl *gomock.Controller) *MockimageRemover {
	mock := &MockimageRemover{ctrl: ctrl}
	mock.recorder = &MockimageRemoverMockRecorder{mock}
	return mock
}

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

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

// ClearRepository indicates an expected call of ClearRepository
func (mr *MockimageRemoverMockRecorder) ClearRepository(repoName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearRepository", reflect.TypeOf((*MockimageRemover)(nil).ClearRepository), repoName)
}

// MockpipelineDeployer is a mock of pipelineDeployer interface
type MockpipelineDeployer struct {
	ctrl     *gomock.Controller
	recorder *MockpipelineDeployerMockRecorder
}

// MockpipelineDeployerMockRecorder is the mock recorder for MockpipelineDeployer
type MockpipelineDeployerMockRecorder struct {
	mock *MockpipelineDeployer
}

// NewMockpipelineDeployer creates a new mock instance
func NewMockpipelineDeployer(ctrl *gomock.Controller) *MockpipelineDeployer {
	mock := &MockpipelineDeployer{ctrl: ctrl}
	mock.recorder = &MockpipelineDeployerMockRecorder{mock}
	return mock
}

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

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

// CreatePipeline indicates an expected call of CreatePipeline
func (mr *MockpipelineDeployerMockRecorder) CreatePipeline(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePipeline", reflect.TypeOf((*MockpipelineDeployer)(nil).CreatePipeline), env)
}

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

// UpdatePipeline indicates an expected call of UpdatePipeline
func (mr *MockpipelineDeployerMockRecorder) UpdatePipeline(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePipeline", reflect.TypeOf((*MockpipelineDeployer)(nil).UpdatePipeline), env)
}

// PipelineExists mocks base method
func (m *MockpipelineDeployer) PipelineExists(env *deploy.CreatePipelineInput) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PipelineExists", env)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PipelineExists indicates an expected call of PipelineExists
func (mr *MockpipelineDeployerMockRecorder) PipelineExists(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PipelineExists", reflect.TypeOf((*MockpipelineDeployer)(nil).PipelineExists), env)
}

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

// DeletePipeline indicates an expected call of DeletePipeline
func (mr *MockpipelineDeployerMockRecorder) DeletePipeline(pipelineName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePipeline", reflect.TypeOf((*MockpipelineDeployer)(nil).DeletePipeline), pipelineName)
}

// AddPipelineResourcesToApp mocks base method
func (m *MockpipelineDeployer) AddPipelineResourcesToApp(app *config.Application, region string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPipelineResourcesToApp", app, region)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPipelineResourcesToApp indicates an expected call of AddPipelineResourcesToApp
func (mr *MockpipelineDeployerMockRecorder) AddPipelineResourcesToApp(app, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPipelineResourcesToApp", reflect.TypeOf((*MockpipelineDeployer)(nil).AddPipelineResourcesToApp), app, region)
}

// GetAppResourcesByRegion mocks base method
func (m *MockpipelineDeployer) GetAppResourcesByRegion(app *config.Application, region string) (*stack.AppRegionalResources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAppResourcesByRegion", app, region)
	ret0, _ := ret[0].(*stack.AppRegionalResources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAppResourcesByRegion indicates an expected call of GetAppResourcesByRegion
func (mr *MockpipelineDeployerMockRecorder) GetAppResourcesByRegion(app, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppResourcesByRegion", reflect.TypeOf((*MockpipelineDeployer)(nil).GetAppResourcesByRegion), app, region)
}

// GetRegionalAppResources mocks base method
func (m *MockpipelineDeployer) GetRegionalAppResources(app *config.Application) ([]*stack.AppRegionalResources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegionalAppResources", app)
	ret0, _ := ret[0].([]*stack.AppRegionalResources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionalAppResources indicates an expected call of GetRegionalAppResources
func (mr *MockpipelineDeployerMockRecorder) GetRegionalAppResources(app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionalAppResources", reflect.TypeOf((*MockpipelineDeployer)(nil).GetRegionalAppResources), app)
}

// MockappDeployer is a mock of appDeployer interface
type MockappDeployer struct {
	ctrl     *gomock.Controller
	recorder *MockappDeployerMockRecorder
}

// MockappDeployerMockRecorder is the mock recorder for MockappDeployer
type MockappDeployerMockRecorder struct {
	mock *MockappDeployer
}

// NewMockappDeployer creates a new mock instance
func NewMockappDeployer(ctrl *gomock.Controller) *MockappDeployer {
	mock := &MockappDeployer{ctrl: ctrl}
	mock.recorder = &MockappDeployerMockRecorder{mock}
	return mock
}

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

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

// DeployApp indicates an expected call of DeployApp
func (mr *MockappDeployerMockRecorder) DeployApp(in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployApp", reflect.TypeOf((*MockappDeployer)(nil).DeployApp), in)
}

// AddServiceToApp mocks base method
func (m *MockappDeployer) AddServiceToApp(app *config.Application, svcName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddServiceToApp", app, svcName)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddServiceToApp indicates an expected call of AddServiceToApp
func (mr *MockappDeployerMockRecorder) AddServiceToApp(app, svcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddServiceToApp", reflect.TypeOf((*MockappDeployer)(nil).AddServiceToApp), app, svcName)
}

// AddEnvToApp mocks base method
func (m *MockappDeployer) AddEnvToApp(app *config.Application, env *config.Environment) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEnvToApp", app, env)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddEnvToApp indicates an expected call of AddEnvToApp
func (mr *MockappDeployerMockRecorder) AddEnvToApp(app, env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEnvToApp", reflect.TypeOf((*MockappDeployer)(nil).AddEnvToApp), app, env)
}

// DelegateDNSPermissions mocks base method
func (m *MockappDeployer) DelegateDNSPermissions(app *config.Application, accountID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DelegateDNSPermissions", app, accountID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DelegateDNSPermissions indicates an expected call of DelegateDNSPermissions
func (mr *MockappDeployerMockRecorder) DelegateDNSPermissions(app, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelegateDNSPermissions", reflect.TypeOf((*MockappDeployer)(nil).DelegateDNSPermissions), app, accountID)
}

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

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

// MockappResourcesGetter is a mock of appResourcesGetter interface
type MockappResourcesGetter struct {
	ctrl     *gomock.Controller
	recorder *MockappResourcesGetterMockRecorder
}

// MockappResourcesGetterMockRecorder is the mock recorder for MockappResourcesGetter
type MockappResourcesGetterMockRecorder struct {
	mock *MockappResourcesGetter
}

// NewMockappResourcesGetter creates a new mock instance
func NewMockappResourcesGetter(ctrl *gomock.Controller) *MockappResourcesGetter {
	mock := &MockappResourcesGetter{ctrl: ctrl}
	mock.recorder = &MockappResourcesGetterMockRecorder{mock}
	return mock
}

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

// GetAppResourcesByRegion mocks base method
func (m *MockappResourcesGetter) GetAppResourcesByRegion(app *config.Application, region string) (*stack.AppRegionalResources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAppResourcesByRegion", app, region)
	ret0, _ := ret[0].(*stack.AppRegionalResources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAppResourcesByRegion indicates an expected call of GetAppResourcesByRegion
func (mr *MockappResourcesGetterMockRecorder) GetAppResourcesByRegion(app, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppResourcesByRegion", reflect.TypeOf((*MockappResourcesGetter)(nil).GetAppResourcesByRegion), app, region)
}

// GetRegionalAppResources mocks base method
func (m *MockappResourcesGetter) GetRegionalAppResources(app *config.Application) ([]*stack.AppRegionalResources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegionalAppResources", app)
	ret0, _ := ret[0].([]*stack.AppRegionalResources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionalAppResources indicates an expected call of GetRegionalAppResources
func (mr *MockappResourcesGetterMockRecorder) GetRegionalAppResources(app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionalAppResources", reflect.TypeOf((*MockappResourcesGetter)(nil).GetRegionalAppResources), app)
}

// Mockdeployer is a mock of deployer interface
type Mockdeployer struct {
	ctrl     *gomock.Controller
	recorder *MockdeployerMockRecorder
}

// MockdeployerMockRecorder is the mock recorder for Mockdeployer
type MockdeployerMockRecorder struct {
	mock *Mockdeployer
}

// NewMockdeployer creates a new mock instance
func NewMockdeployer(ctrl *gomock.Controller) *Mockdeployer {
	mock := &Mockdeployer{ctrl: ctrl}
	mock.recorder = &MockdeployerMockRecorder{mock}
	return mock
}

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

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

// DeployEnvironment indicates an expected call of DeployEnvironment
func (mr *MockdeployerMockRecorder) DeployEnvironment(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployEnvironment", reflect.TypeOf((*Mockdeployer)(nil).DeployEnvironment), env)
}

// StreamEnvironmentCreation mocks base method
func (m *Mockdeployer) StreamEnvironmentCreation(env *deploy.CreateEnvironmentInput) (<-chan []deploy.ResourceEvent, <-chan deploy.CreateEnvironmentResponse) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamEnvironmentCreation", env)
	ret0, _ := ret[0].(<-chan []deploy.ResourceEvent)
	ret1, _ := ret[1].(<-chan deploy.CreateEnvironmentResponse)
	return ret0, ret1
}

// StreamEnvironmentCreation indicates an expected call of StreamEnvironmentCreation
func (mr *MockdeployerMockRecorder) StreamEnvironmentCreation(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamEnvironmentCreation", reflect.TypeOf((*Mockdeployer)(nil).StreamEnvironmentCreation), env)
}

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

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

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

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

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

// DeployApp indicates an expected call of DeployApp
func (mr *MockdeployerMockRecorder) DeployApp(in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployApp", reflect.TypeOf((*Mockdeployer)(nil).DeployApp), in)
}

// AddServiceToApp mocks base method
func (m *Mockdeployer) AddServiceToApp(app *config.Application, svcName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddServiceToApp", app, svcName)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddServiceToApp indicates an expected call of AddServiceToApp
func (mr *MockdeployerMockRecorder) AddServiceToApp(app, svcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddServiceToApp", reflect.TypeOf((*Mockdeployer)(nil).AddServiceToApp), app, svcName)
}

// AddEnvToApp mocks base method
func (m *Mockdeployer) AddEnvToApp(app *config.Application, env *config.Environment) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEnvToApp", app, env)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddEnvToApp indicates an expected call of AddEnvToApp
func (mr *MockdeployerMockRecorder) AddEnvToApp(app, env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEnvToApp", reflect.TypeOf((*Mockdeployer)(nil).AddEnvToApp), app, env)
}

// DelegateDNSPermissions mocks base method
func (m *Mockdeployer) DelegateDNSPermissions(app *config.Application, accountID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DelegateDNSPermissions", app, accountID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DelegateDNSPermissions indicates an expected call of DelegateDNSPermissions
func (mr *MockdeployerMockRecorder) DelegateDNSPermissions(app, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelegateDNSPermissions", reflect.TypeOf((*Mockdeployer)(nil).DelegateDNSPermissions), app, accountID)
}

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

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

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

// CreatePipeline indicates an expected call of CreatePipeline
func (mr *MockdeployerMockRecorder) CreatePipeline(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePipeline", reflect.TypeOf((*Mockdeployer)(nil).CreatePipeline), env)
}

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

// UpdatePipeline indicates an expected call of UpdatePipeline
func (mr *MockdeployerMockRecorder) UpdatePipeline(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePipeline", reflect.TypeOf((*Mockdeployer)(nil).UpdatePipeline), env)
}

// PipelineExists mocks base method
func (m *Mockdeployer) PipelineExists(env *deploy.CreatePipelineInput) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PipelineExists", env)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PipelineExists indicates an expected call of PipelineExists
func (mr *MockdeployerMockRecorder) PipelineExists(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PipelineExists", reflect.TypeOf((*Mockdeployer)(nil).PipelineExists), env)
}

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

// DeletePipeline indicates an expected call of DeletePipeline
func (mr *MockdeployerMockRecorder) DeletePipeline(pipelineName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePipeline", reflect.TypeOf((*Mockdeployer)(nil).DeletePipeline), pipelineName)
}

// AddPipelineResourcesToApp mocks base method
func (m *Mockdeployer) AddPipelineResourcesToApp(app *config.Application, region string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPipelineResourcesToApp", app, region)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPipelineResourcesToApp indicates an expected call of AddPipelineResourcesToApp
func (mr *MockdeployerMockRecorder) AddPipelineResourcesToApp(app, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPipelineResourcesToApp", reflect.TypeOf((*Mockdeployer)(nil).AddPipelineResourcesToApp), app, region)
}

// GetAppResourcesByRegion mocks base method
func (m *Mockdeployer) GetAppResourcesByRegion(app *config.Application, region string) (*stack.AppRegionalResources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAppResourcesByRegion", app, region)
	ret0, _ := ret[0].(*stack.AppRegionalResources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAppResourcesByRegion indicates an expected call of GetAppResourcesByRegion
func (mr *MockdeployerMockRecorder) GetAppResourcesByRegion(app, region interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppResourcesByRegion", reflect.TypeOf((*Mockdeployer)(nil).GetAppResourcesByRegion), app, region)
}

// GetRegionalAppResources mocks base method
func (m *Mockdeployer) GetRegionalAppResources(app *config.Application) ([]*stack.AppRegionalResources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegionalAppResources", app)
	ret0, _ := ret[0].([]*stack.AppRegionalResources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionalAppResources indicates an expected call of GetRegionalAppResources
func (mr *MockdeployerMockRecorder) GetRegionalAppResources(app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionalAppResources", reflect.TypeOf((*Mockdeployer)(nil).GetRegionalAppResources), app)
}

// MockdomainValidator is a mock of domainValidator interface
type MockdomainValidator struct {
	ctrl     *gomock.Controller
	recorder *MockdomainValidatorMockRecorder
}

// MockdomainValidatorMockRecorder is the mock recorder for MockdomainValidator
type MockdomainValidatorMockRecorder struct {
	mock *MockdomainValidator
}

// NewMockdomainValidator creates a new mock instance
func NewMockdomainValidator(ctrl *gomock.Controller) *MockdomainValidator {
	mock := &MockdomainValidator{ctrl: ctrl}
	mock.recorder = &MockdomainValidatorMockRecorder{mock}
	return mock
}

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

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

// DomainExists indicates an expected call of DomainExists
func (mr *MockdomainValidatorMockRecorder) DomainExists(domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainExists", reflect.TypeOf((*MockdomainValidator)(nil).DomainExists), domainName)
}

// MockdockerfileParser is a mock of dockerfileParser interface
type MockdockerfileParser struct {
	ctrl     *gomock.Controller
	recorder *MockdockerfileParserMockRecorder
}

// MockdockerfileParserMockRecorder is the mock recorder for MockdockerfileParser
type MockdockerfileParserMockRecorder struct {
	mock *MockdockerfileParser
}

// NewMockdockerfileParser creates a new mock instance
func NewMockdockerfileParser(ctrl *gomock.Controller) *MockdockerfileParser {
	mock := &MockdockerfileParser{ctrl: ctrl}
	mock.recorder = &MockdockerfileParserMockRecorder{mock}
	return mock
}

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

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

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

// MockserviceArnGetter is a mock of serviceArnGetter interface
type MockserviceArnGetter struct {
	ctrl     *gomock.Controller
	recorder *MockserviceArnGetterMockRecorder
}

// MockserviceArnGetterMockRecorder is the mock recorder for MockserviceArnGetter
type MockserviceArnGetterMockRecorder struct {
	mock *MockserviceArnGetter
}

// NewMockserviceArnGetter creates a new mock instance
func NewMockserviceArnGetter(ctrl *gomock.Controller) *MockserviceArnGetter {
	mock := &MockserviceArnGetter{ctrl: ctrl}
	mock.recorder = &MockserviceArnGetterMockRecorder{mock}
	return mock
}

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

// GetServiceArn mocks base method
func (m *MockserviceArnGetter) GetServiceArn() (*ecs.ServiceArn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceArn")
	ret0, _ := ret[0].(*ecs.ServiceArn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockstatusDescriber is a mock of statusDescriber interface
type MockstatusDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockstatusDescriberMockRecorder
}

// MockstatusDescriberMockRecorder is the mock recorder for MockstatusDescriber
type MockstatusDescriberMockRecorder struct {
	mock *MockstatusDescriber
}

// NewMockstatusDescriber creates a new mock instance
func NewMockstatusDescriber(ctrl *gomock.Controller) *MockstatusDescriber {
	mock := &MockstatusDescriber{ctrl: ctrl}
	mock.recorder = &MockstatusDescriberMockRecorder{mock}
	return mock
}

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

// Describe mocks base method
func (m *MockstatusDescriber) Describe() (*describe.ServiceStatusDesc, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Describe")
	ret0, _ := ret[0].(*describe.ServiceStatusDesc)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockenvDescriber is a mock of envDescriber interface
type MockenvDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockenvDescriberMockRecorder
}

// MockenvDescriberMockRecorder is the mock recorder for MockenvDescriber
type MockenvDescriberMockRecorder struct {
	mock *MockenvDescriber
}

// NewMockenvDescriber creates a new mock instance
func NewMockenvDescriber(ctrl *gomock.Controller) *MockenvDescriber {
	mock := &MockenvDescriber{ctrl: ctrl}
	mock.recorder = &MockenvDescriberMockRecorder{mock}
	return mock
}

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

// Describe mocks base method
func (m *MockenvDescriber) Describe() (*describe.EnvDescription, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Describe")
	ret0, _ := ret[0].(*describe.EnvDescription)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockpipelineStatusDescriber is a mock of pipelineStatusDescriber interface
type MockpipelineStatusDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockpipelineStatusDescriberMockRecorder
}

// MockpipelineStatusDescriberMockRecorder is the mock recorder for MockpipelineStatusDescriber
type MockpipelineStatusDescriberMockRecorder struct {
	mock *MockpipelineStatusDescriber
}

// NewMockpipelineStatusDescriber creates a new mock instance
func NewMockpipelineStatusDescriber(ctrl *gomock.Controller) *MockpipelineStatusDescriber {
	mock := &MockpipelineStatusDescriber{ctrl: ctrl}
	mock.recorder = &MockpipelineStatusDescriberMockRecorder{mock}
	return mock
}

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

// Describe mocks base method
func (m *MockpipelineStatusDescriber) Describe() (*describe.PipelineStatusDesc, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Describe")
	ret0, _ := ret[0].(*describe.PipelineStatusDesc)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockresourceGroupsClient is a mock of resourceGroupsClient interface
type MockresourceGroupsClient struct {
	ctrl     *gomock.Controller
	recorder *MockresourceGroupsClientMockRecorder
}

// MockresourceGroupsClientMockRecorder is the mock recorder for MockresourceGroupsClient
type MockresourceGroupsClientMockRecorder struct {
	mock *MockresourceGroupsClient
}

// NewMockresourceGroupsClient creates a new mock instance
func NewMockresourceGroupsClient(ctrl *gomock.Controller) *MockresourceGroupsClient {
	mock := &MockresourceGroupsClient{ctrl: ctrl}
	mock.recorder = &MockresourceGroupsClientMockRecorder{mock}
	return mock
}

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

// GetResourcesByTags mocks base method
func (m *MockresourceGroupsClient) GetResourcesByTags(resourceType string, tags map[string]string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourcesByTags", resourceType, tags)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcesByTags indicates an expected call of GetResourcesByTags
func (mr *MockresourceGroupsClientMockRecorder) GetResourcesByTags(resourceType, tags interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcesByTags", reflect.TypeOf((*MockresourceGroupsClient)(nil).GetResourcesByTags), resourceType, tags)
}

// MockpipelineGetter is a mock of pipelineGetter interface
type MockpipelineGetter struct {
	ctrl     *gomock.Controller
	recorder *MockpipelineGetterMockRecorder
}

// MockpipelineGetterMockRecorder is the mock recorder for MockpipelineGetter
type MockpipelineGetterMockRecorder struct {
	mock *MockpipelineGetter
}

// NewMockpipelineGetter creates a new mock instance
func NewMockpipelineGetter(ctrl *gomock.Controller) *MockpipelineGetter {
	mock := &MockpipelineGetter{ctrl: ctrl}
	mock.recorder = &MockpipelineGetterMockRecorder{mock}
	return mock
}

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

// GetPipeline mocks base method
func (m *MockpipelineGetter) GetPipeline(pipelineName string) (*codepipeline.Pipeline, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipeline", pipelineName)
	ret0, _ := ret[0].(*codepipeline.Pipeline)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPipeline indicates an expected call of GetPipeline
func (mr *MockpipelineGetterMockRecorder) GetPipeline(pipelineName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPipeline", reflect.TypeOf((*MockpipelineGetter)(nil).GetPipeline), pipelineName)
}

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

// ListPipelineNamesByTags indicates an expected call of ListPipelineNamesByTags
func (mr *MockpipelineGetterMockRecorder) ListPipelineNamesByTags(tags interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineNamesByTags", reflect.TypeOf((*MockpipelineGetter)(nil).ListPipelineNamesByTags), tags)
}

// MockpipelineStateGetter is a mock of pipelineStateGetter interface
type MockpipelineStateGetter struct {
	ctrl     *gomock.Controller
	recorder *MockpipelineStateGetterMockRecorder
}

// MockpipelineStateGetterMockRecorder is the mock recorder for MockpipelineStateGetter
type MockpipelineStateGetterMockRecorder struct {
	mock *MockpipelineStateGetter
}

// NewMockpipelineStateGetter creates a new mock instance
func NewMockpipelineStateGetter(ctrl *gomock.Controller) *MockpipelineStateGetter {
	mock := &MockpipelineStateGetter{ctrl: ctrl}
	mock.recorder = &MockpipelineStateGetterMockRecorder{mock}
	return mock
}

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

// GetPipelineState mocks base method
func (m *MockpipelineStateGetter) GetPipelineState(pipelineName string) (*codepipeline.PipelineState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineState", pipelineName)
	ret0, _ := ret[0].(*codepipeline.PipelineState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPipelineState indicates an expected call of GetPipelineState
func (mr *MockpipelineStateGetterMockRecorder) GetPipelineState(pipelineName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPipelineState", reflect.TypeOf((*MockpipelineStateGetter)(nil).GetPipelineState), pipelineName)
}

// Mockexecutor is a mock of executor interface
type Mockexecutor struct {
	ctrl     *gomock.Controller
	recorder *MockexecutorMockRecorder
}

// MockexecutorMockRecorder is the mock recorder for Mockexecutor
type MockexecutorMockRecorder struct {
	mock *Mockexecutor
}

// NewMockexecutor creates a new mock instance
func NewMockexecutor(ctrl *gomock.Controller) *Mockexecutor {
	mock := &Mockexecutor{ctrl: ctrl}
	mock.recorder = &MockexecutorMockRecorder{mock}
	return mock
}

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

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

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

// MockdeletePipelineRunner is a mock of deletePipelineRunner interface
type MockdeletePipelineRunner struct {
	ctrl     *gomock.Controller
	recorder *MockdeletePipelineRunnerMockRecorder
}

// MockdeletePipelineRunnerMockRecorder is the mock recorder for MockdeletePipelineRunner
type MockdeletePipelineRunnerMockRecorder struct {
	mock *MockdeletePipelineRunner
}

// NewMockdeletePipelineRunner creates a new mock instance
func NewMockdeletePipelineRunner(ctrl *gomock.Controller) *MockdeletePipelineRunner {
	mock := &MockdeletePipelineRunner{ctrl: ctrl}
	mock.recorder = &MockdeletePipelineRunnerMockRecorder{mock}
	return mock
}

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

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

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

// MockaskExecutor is a mock of askExecutor interface
type MockaskExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockaskExecutorMockRecorder
}

// MockaskExecutorMockRecorder is the mock recorder for MockaskExecutor
type MockaskExecutorMockRecorder struct {
	mock *MockaskExecutor
}

// NewMockaskExecutor creates a new mock instance
func NewMockaskExecutor(ctrl *gomock.Controller) *MockaskExecutor {
	mock := &MockaskExecutor{ctrl: ctrl}
	mock.recorder = &MockaskExecutorMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockappSelector is a mock of appSelector interface
type MockappSelector struct {
	ctrl     *gomock.Controller
	recorder *MockappSelectorMockRecorder
}

// MockappSelectorMockRecorder is the mock recorder for MockappSelector
type MockappSelectorMockRecorder struct {
	mock *MockappSelector
}

// NewMockappSelector creates a new mock instance
func NewMockappSelector(ctrl *gomock.Controller) *MockappSelector {
	mock := &MockappSelector{ctrl: ctrl}
	mock.recorder = &MockappSelectorMockRecorder{mock}
	return mock
}

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

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

// Application indicates an expected call of Application
func (mr *MockappSelectorMockRecorder) Application(prompt, help interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Application", reflect.TypeOf((*MockappSelector)(nil).Application), prompt, help)
}

// MockappEnvSelector is a mock of appEnvSelector interface
type MockappEnvSelector struct {
	ctrl     *gomock.Controller
	recorder *MockappEnvSelectorMockRecorder
}

// MockappEnvSelectorMockRecorder is the mock recorder for MockappEnvSelector
type MockappEnvSelectorMockRecorder struct {
	mock *MockappEnvSelector
}

// NewMockappEnvSelector creates a new mock instance
func NewMockappEnvSelector(ctrl *gomock.Controller) *MockappEnvSelector {
	mock := &MockappEnvSelector{ctrl: ctrl}
	mock.recorder = &MockappEnvSelectorMockRecorder{mock}
	return mock
}

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

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

// Application indicates an expected call of Application
func (mr *MockappEnvSelectorMockRecorder) Application(prompt, help interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Application", reflect.TypeOf((*MockappEnvSelector)(nil).Application), prompt, help)
}

// Environment mocks base method
func (m *MockappEnvSelector) Environment(prompt, help, app string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Environment", prompt, help, app)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Environment indicates an expected call of Environment
func (mr *MockappEnvSelectorMockRecorder) Environment(prompt, help, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Environment", reflect.TypeOf((*MockappEnvSelector)(nil).Environment), prompt, help, app)
}

// MockconfigSelector is a mock of configSelector interface
type MockconfigSelector struct {
	ctrl     *gomock.Controller
	recorder *MockconfigSelectorMockRecorder
}

// MockconfigSelectorMockRecorder is the mock recorder for MockconfigSelector
type MockconfigSelectorMockRecorder struct {
	mock *MockconfigSelector
}

// NewMockconfigSelector creates a new mock instance
func NewMockconfigSelector(ctrl *gomock.Controller) *MockconfigSelector {
	mock := &MockconfigSelector{ctrl: ctrl}
	mock.recorder = &MockconfigSelectorMockRecorder{mock}
	return mock
}

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

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

// Application indicates an expected call of Application
func (mr *MockconfigSelectorMockRecorder) Application(prompt, help interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Application", reflect.TypeOf((*MockconfigSelector)(nil).Application), prompt, help)
}

// Environment mocks base method
func (m *MockconfigSelector) Environment(prompt, help, app string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Environment", prompt, help, app)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Environment indicates an expected call of Environment
func (mr *MockconfigSelectorMockRecorder) Environment(prompt, help, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Environment", reflect.TypeOf((*MockconfigSelector)(nil).Environment), prompt, help, app)
}

// Service mocks base method
func (m *MockconfigSelector) Service(prompt, help, app string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Service", prompt, help, app)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Service indicates an expected call of Service
func (mr *MockconfigSelectorMockRecorder) Service(prompt, help, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Service", reflect.TypeOf((*MockconfigSelector)(nil).Service), prompt, help, app)
}

// MockwsSelector is a mock of wsSelector interface
type MockwsSelector struct {
	ctrl     *gomock.Controller
	recorder *MockwsSelectorMockRecorder
}

// MockwsSelectorMockRecorder is the mock recorder for MockwsSelector
type MockwsSelectorMockRecorder struct {
	mock *MockwsSelector
}

// NewMockwsSelector creates a new mock instance
func NewMockwsSelector(ctrl *gomock.Controller) *MockwsSelector {
	mock := &MockwsSelector{ctrl: ctrl}
	mock.recorder = &MockwsSelectorMockRecorder{mock}
	return mock
}

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

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

// Application indicates an expected call of Application
func (mr *MockwsSelectorMockRecorder) Application(prompt, help interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Application", reflect.TypeOf((*MockwsSelector)(nil).Application), prompt, help)
}

// Environment mocks base method
func (m *MockwsSelector) Environment(prompt, help, app string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Environment", prompt, help, app)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Environment indicates an expected call of Environment
func (mr *MockwsSelectorMockRecorder) Environment(prompt, help, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Environment", reflect.TypeOf((*MockwsSelector)(nil).Environment), prompt, help, app)
}

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

// Service indicates an expected call of Service
func (mr *MockwsSelectorMockRecorder) Service(prompt, help interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Service", reflect.TypeOf((*MockwsSelector)(nil).Service), prompt, help)
}

You'll need to regenerate the mocks to get rid of this now that you've removed the interfaces from `cli/interfaces.go`