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

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

import (
	reflect "reflect"

	apprunner "github.com/aws/copilot-cli/internal/pkg/aws/apprunner"
	cloudwatch "github.com/aws/copilot-cli/internal/pkg/aws/cloudwatch"
	ecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
	config "github.com/aws/copilot-cli/internal/pkg/config"
	stack "github.com/aws/copilot-cli/internal/pkg/describe/stack"
	gomock "github.com/golang/mock/gomock"
)

// MockConfigStoreSvc is a mock of ConfigStoreSvc interface.
type MockConfigStoreSvc struct {
	ctrl     *gomock.Controller
	recorder *MockConfigStoreSvcMockRecorder
}

// MockConfigStoreSvcMockRecorder is the mock recorder for MockConfigStoreSvc.
type MockConfigStoreSvcMockRecorder struct {
	mock *MockConfigStoreSvc
}

// NewMockConfigStoreSvc creates a new mock instance.
func NewMockConfigStoreSvc(ctrl *gomock.Controller) *MockConfigStoreSvc {
	mock := &MockConfigStoreSvc{ctrl: ctrl}
	mock.recorder = &MockConfigStoreSvcMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockDeployedEnvServicesLister is a mock of DeployedEnvServicesLister interface.
type MockDeployedEnvServicesLister struct {
	ctrl     *gomock.Controller
	recorder *MockDeployedEnvServicesListerMockRecorder
}

// MockDeployedEnvServicesListerMockRecorder is the mock recorder for MockDeployedEnvServicesLister.
type MockDeployedEnvServicesListerMockRecorder struct {
	mock *MockDeployedEnvServicesLister
}

// NewMockDeployedEnvServicesLister creates a new mock instance.
func NewMockDeployedEnvServicesLister(ctrl *gomock.Controller) *MockDeployedEnvServicesLister {
	mock := &MockDeployedEnvServicesLister{ctrl: ctrl}
	mock.recorder = &MockDeployedEnvServicesListerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockecsClient is a mock of ecsClient interface.
type MockecsClient struct {
	ctrl     *gomock.Controller
	recorder *MockecsClientMockRecorder
}

// MockecsClientMockRecorder is the mock recorder for MockecsClient.
type MockecsClientMockRecorder struct {
	mock *MockecsClient
}

// NewMockecsClient creates a new mock instance.
func NewMockecsClient(ctrl *gomock.Controller) *MockecsClient {
	mock := &MockecsClient{ctrl: ctrl}
	mock.recorder = &MockecsClientMockRecorder{mock}
	return mock
}

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

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

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

// TaskDefinition mocks base method.
func (m *MockecsClient) TaskDefinition(app, env, svc string) (*ecs.TaskDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TaskDefinition", app, env, svc)
	ret0, _ := ret[0].(*ecs.TaskDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockapprunnerClient is a mock of apprunnerClient interface.
type MockapprunnerClient struct {
	ctrl     *gomock.Controller
	recorder *MockapprunnerClientMockRecorder
}

// MockapprunnerClientMockRecorder is the mock recorder for MockapprunnerClient.
type MockapprunnerClientMockRecorder struct {
	mock *MockapprunnerClient
}

// NewMockapprunnerClient creates a new mock instance.
func NewMockapprunnerClient(ctrl *gomock.Controller) *MockapprunnerClient {
	mock := &MockapprunnerClient{ctrl: ctrl}
	mock.recorder = &MockapprunnerClientMockRecorder{mock}
	return mock
}

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

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

// DescribeService indicates an expected call of DescribeService.
func (mr *MockapprunnerClientMockRecorder) DescribeService(svcARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeService", reflect.TypeOf((*MockapprunnerClient)(nil).DescribeService), svcARN)
}

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

// PrivateURL indicates an expected call of PrivateURL.
func (mr *MockapprunnerClientMockRecorder) PrivateURL(vicARN interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrivateURL", reflect.TypeOf((*MockapprunnerClient)(nil).PrivateURL), vicARN)
}

// MockworkloadDescriber is a mock of workloadDescriber interface.
type MockworkloadDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockworkloadDescriberMockRecorder
}

// MockworkloadDescriberMockRecorder is the mock recorder for MockworkloadDescriber.
type MockworkloadDescriberMockRecorder struct {
	mock *MockworkloadDescriber
}

// NewMockworkloadDescriber creates a new mock instance.
func NewMockworkloadDescriber(ctrl *gomock.Controller) *MockworkloadDescriber {
	mock := &MockworkloadDescriber{ctrl: ctrl}
	mock.recorder = &MockworkloadDescriberMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockecsDescriber is a mock of ecsDescriber interface.
type MockecsDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockecsDescriberMockRecorder
}

// MockecsDescriberMockRecorder is the mock recorder for MockecsDescriber.
type MockecsDescriberMockRecorder struct {
	mock *MockecsDescriber
}

// NewMockecsDescriber creates a new mock instance.
func NewMockecsDescriber(ctrl *gomock.Controller) *MockecsDescriber {
	mock := &MockecsDescriber{ctrl: ctrl}
	mock.recorder = &MockecsDescriberMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockapprunnerDescriber is a mock of apprunnerDescriber interface.
type MockapprunnerDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockapprunnerDescriberMockRecorder
}

// MockapprunnerDescriberMockRecorder is the mock recorder for MockapprunnerDescriber.
type MockapprunnerDescriberMockRecorder struct {
	mock *MockapprunnerDescriber
}

// NewMockapprunnerDescriber creates a new mock instance.
func NewMockapprunnerDescriber(ctrl *gomock.Controller) *MockapprunnerDescriber {
	mock := &MockapprunnerDescriber{ctrl: ctrl}
	mock.recorder = &MockapprunnerDescriberMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockcwAlarmDescriber is a mock of cwAlarmDescriber interface.
type MockcwAlarmDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockcwAlarmDescriberMockRecorder
}

// MockcwAlarmDescriberMockRecorder is the mock recorder for MockcwAlarmDescriber.
type MockcwAlarmDescriberMockRecorder struct {
	mock *MockcwAlarmDescriber
}

// NewMockcwAlarmDescriber creates a new mock instance.
func NewMockcwAlarmDescriber(ctrl *gomock.Controller) *MockcwAlarmDescriber {
	mock := &MockcwAlarmDescriber{ctrl: ctrl}
	mock.recorder = &MockcwAlarmDescriberMockRecorder{mock}
	return mock
}

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

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

// AlarmDescriptions indicates an expected call of AlarmDescriptions.
func (mr *MockcwAlarmDescriberMockRecorder) AlarmDescriptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlarmDescriptions", reflect.TypeOf((*MockcwAlarmDescriber)(nil).AlarmDescriptions), arg0)
}

// MockbucketDescriber is a mock of bucketDescriber interface.
type MockbucketDescriber struct {
	ctrl     *gomock.Controller
	recorder *MockbucketDescriberMockRecorder
}

// MockbucketDescriberMockRecorder is the mock recorder for MockbucketDescriber.
type MockbucketDescriberMockRecorder struct {
	mock *MockbucketDescriber
}

// NewMockbucketDescriber creates a new mock instance.
func NewMockbucketDescriber(ctrl *gomock.Controller) *MockbucketDescriber {
	mock := &MockbucketDescriber{ctrl: ctrl}
	mock.recorder = &MockbucketDescriberMockRecorder{mock}
	return mock
}

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

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

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

// MockbucketDataGetter is a mock of bucketDataGetter interface.
type MockbucketDataGetter struct {
	ctrl     *gomock.Controller
	recorder *MockbucketDataGetterMockRecorder
}

// MockbucketDataGetterMockRecorder is the mock recorder for MockbucketDataGetter.
type MockbucketDataGetterMockRecorder struct {
	mock *MockbucketDataGetter
}

// NewMockbucketDataGetter creates a new mock instance.
func NewMockbucketDataGetter(ctrl *gomock.Controller) *MockbucketDataGetter {
	mock := &MockbucketDataGetter{ctrl: ctrl}
	mock.recorder = &MockbucketDataGetterMockRecorder{mock}
	return mock
}

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

// BucketSizeAndCount mocks base method.
func (m *MockbucketDataGetter) BucketSizeAndCount(bucket string) (string, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BucketSizeAndCount", bucket)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MockbucketNameGetter is a mock of bucketNameGetter interface.
type MockbucketNameGetter struct {
	ctrl     *gomock.Controller
	recorder *MockbucketNameGetterMockRecorder
}

// MockbucketNameGetterMockRecorder is the mock recorder for MockbucketNameGetter.
type MockbucketNameGetterMockRecorder struct {
	mock *MockbucketNameGetter
}

// NewMockbucketNameGetter creates a new mock instance.
func NewMockbucketNameGetter(ctrl *gomock.Controller) *MockbucketNameGetter {
	mock := &MockbucketNameGetter{ctrl: ctrl}
	mock.recorder = &MockbucketNameGetterMockRecorder{mock}
	return mock
}

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

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

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