github.com/tetrafolium/tflint@v0.8.0/mock/ecsmock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: vendor/github.com/aws/aws-sdk-go/service/ecs/ecsiface/interface.go

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

import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	ecs "github.com/aws/aws-sdk-go/service/ecs"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockECSAPI is a mock of ECSAPI interface
type MockECSAPI struct {
	ctrl     *gomock.Controller
	recorder *MockECSAPIMockRecorder
}

// MockECSAPIMockRecorder is the mock recorder for MockECSAPI
type MockECSAPIMockRecorder struct {
	mock *MockECSAPI
}

// NewMockECSAPI creates a new mock instance
func NewMockECSAPI(ctrl *gomock.Controller) *MockECSAPI {
	mock := &MockECSAPI{ctrl: ctrl}
	mock.recorder = &MockECSAPIMockRecorder{mock}
	return mock
}

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

// CreateCluster mocks base method
func (m *MockECSAPI) CreateCluster(arg0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) {
	ret := m.ctrl.Call(m, "CreateCluster", arg0)
	ret0, _ := ret[0].(*ecs.CreateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster
func (mr *MockECSAPIMockRecorder) CreateCluster(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockECSAPI)(nil).CreateCluster), arg0)
}

// CreateClusterWithContext mocks base method
func (m *MockECSAPI) CreateClusterWithContext(arg0 aws.Context, arg1 *ecs.CreateClusterInput, arg2 ...request.Option) (*ecs.CreateClusterOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateClusterWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.CreateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClusterWithContext indicates an expected call of CreateClusterWithContext
func (mr *MockECSAPIMockRecorder) CreateClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterWithContext", reflect.TypeOf((*MockECSAPI)(nil).CreateClusterWithContext), varargs...)
}

// CreateClusterRequest mocks base method
func (m *MockECSAPI) CreateClusterRequest(arg0 *ecs.CreateClusterInput) (*request.Request, *ecs.CreateClusterOutput) {
	ret := m.ctrl.Call(m, "CreateClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.CreateClusterOutput)
	return ret0, ret1
}

// CreateClusterRequest indicates an expected call of CreateClusterRequest
func (mr *MockECSAPIMockRecorder) CreateClusterRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterRequest", reflect.TypeOf((*MockECSAPI)(nil).CreateClusterRequest), arg0)
}

// CreateService mocks base method
func (m *MockECSAPI) CreateService(arg0 *ecs.CreateServiceInput) (*ecs.CreateServiceOutput, error) {
	ret := m.ctrl.Call(m, "CreateService", arg0)
	ret0, _ := ret[0].(*ecs.CreateServiceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateService indicates an expected call of CreateService
func (mr *MockECSAPIMockRecorder) CreateService(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateService", reflect.TypeOf((*MockECSAPI)(nil).CreateService), arg0)
}

// CreateServiceWithContext mocks base method
func (m *MockECSAPI) CreateServiceWithContext(arg0 aws.Context, arg1 *ecs.CreateServiceInput, arg2 ...request.Option) (*ecs.CreateServiceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateServiceWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.CreateServiceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateServiceWithContext indicates an expected call of CreateServiceWithContext
func (mr *MockECSAPIMockRecorder) CreateServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceWithContext", reflect.TypeOf((*MockECSAPI)(nil).CreateServiceWithContext), varargs...)
}

// CreateServiceRequest mocks base method
func (m *MockECSAPI) CreateServiceRequest(arg0 *ecs.CreateServiceInput) (*request.Request, *ecs.CreateServiceOutput) {
	ret := m.ctrl.Call(m, "CreateServiceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.CreateServiceOutput)
	return ret0, ret1
}

// CreateServiceRequest indicates an expected call of CreateServiceRequest
func (mr *MockECSAPIMockRecorder) CreateServiceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceRequest", reflect.TypeOf((*MockECSAPI)(nil).CreateServiceRequest), arg0)
}

// DeleteAttributes mocks base method
func (m *MockECSAPI) DeleteAttributes(arg0 *ecs.DeleteAttributesInput) (*ecs.DeleteAttributesOutput, error) {
	ret := m.ctrl.Call(m, "DeleteAttributes", arg0)
	ret0, _ := ret[0].(*ecs.DeleteAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAttributes indicates an expected call of DeleteAttributes
func (mr *MockECSAPIMockRecorder) DeleteAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttributes", reflect.TypeOf((*MockECSAPI)(nil).DeleteAttributes), arg0)
}

// DeleteAttributesWithContext mocks base method
func (m *MockECSAPI) DeleteAttributesWithContext(arg0 aws.Context, arg1 *ecs.DeleteAttributesInput, arg2 ...request.Option) (*ecs.DeleteAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DeleteAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAttributesWithContext indicates an expected call of DeleteAttributesWithContext
func (mr *MockECSAPIMockRecorder) DeleteAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttributesWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteAttributesWithContext), varargs...)
}

// DeleteAttributesRequest mocks base method
func (m *MockECSAPI) DeleteAttributesRequest(arg0 *ecs.DeleteAttributesInput) (*request.Request, *ecs.DeleteAttributesOutput) {
	ret := m.ctrl.Call(m, "DeleteAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DeleteAttributesOutput)
	return ret0, ret1
}

// DeleteAttributesRequest indicates an expected call of DeleteAttributesRequest
func (mr *MockECSAPIMockRecorder) DeleteAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttributesRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteAttributesRequest), arg0)
}

// DeleteCluster mocks base method
func (m *MockECSAPI) DeleteCluster(arg0 *ecs.DeleteClusterInput) (*ecs.DeleteClusterOutput, error) {
	ret := m.ctrl.Call(m, "DeleteCluster", arg0)
	ret0, _ := ret[0].(*ecs.DeleteClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCluster indicates an expected call of DeleteCluster
func (mr *MockECSAPIMockRecorder) DeleteCluster(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCluster", reflect.TypeOf((*MockECSAPI)(nil).DeleteCluster), arg0)
}

// DeleteClusterWithContext mocks base method
func (m *MockECSAPI) DeleteClusterWithContext(arg0 aws.Context, arg1 *ecs.DeleteClusterInput, arg2 ...request.Option) (*ecs.DeleteClusterOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteClusterWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DeleteClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClusterWithContext indicates an expected call of DeleteClusterWithContext
func (mr *MockECSAPIMockRecorder) DeleteClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteClusterWithContext), varargs...)
}

// DeleteClusterRequest mocks base method
func (m *MockECSAPI) DeleteClusterRequest(arg0 *ecs.DeleteClusterInput) (*request.Request, *ecs.DeleteClusterOutput) {
	ret := m.ctrl.Call(m, "DeleteClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DeleteClusterOutput)
	return ret0, ret1
}

// DeleteClusterRequest indicates an expected call of DeleteClusterRequest
func (mr *MockECSAPIMockRecorder) DeleteClusterRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteClusterRequest), arg0)
}

// DeleteService mocks base method
func (m *MockECSAPI) DeleteService(arg0 *ecs.DeleteServiceInput) (*ecs.DeleteServiceOutput, error) {
	ret := m.ctrl.Call(m, "DeleteService", arg0)
	ret0, _ := ret[0].(*ecs.DeleteServiceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteService indicates an expected call of DeleteService
func (mr *MockECSAPIMockRecorder) DeleteService(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockECSAPI)(nil).DeleteService), arg0)
}

// DeleteServiceWithContext mocks base method
func (m *MockECSAPI) DeleteServiceWithContext(arg0 aws.Context, arg1 *ecs.DeleteServiceInput, arg2 ...request.Option) (*ecs.DeleteServiceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteServiceWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DeleteServiceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteServiceWithContext indicates an expected call of DeleteServiceWithContext
func (mr *MockECSAPIMockRecorder) DeleteServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteServiceWithContext), varargs...)
}

// DeleteServiceRequest mocks base method
func (m *MockECSAPI) DeleteServiceRequest(arg0 *ecs.DeleteServiceInput) (*request.Request, *ecs.DeleteServiceOutput) {
	ret := m.ctrl.Call(m, "DeleteServiceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DeleteServiceOutput)
	return ret0, ret1
}

// DeleteServiceRequest indicates an expected call of DeleteServiceRequest
func (mr *MockECSAPIMockRecorder) DeleteServiceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteServiceRequest), arg0)
}

// DeregisterContainerInstance mocks base method
func (m *MockECSAPI) DeregisterContainerInstance(arg0 *ecs.DeregisterContainerInstanceInput) (*ecs.DeregisterContainerInstanceOutput, error) {
	ret := m.ctrl.Call(m, "DeregisterContainerInstance", arg0)
	ret0, _ := ret[0].(*ecs.DeregisterContainerInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterContainerInstance indicates an expected call of DeregisterContainerInstance
func (mr *MockECSAPIMockRecorder) DeregisterContainerInstance(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterContainerInstance", reflect.TypeOf((*MockECSAPI)(nil).DeregisterContainerInstance), arg0)
}

// DeregisterContainerInstanceWithContext mocks base method
func (m *MockECSAPI) DeregisterContainerInstanceWithContext(arg0 aws.Context, arg1 *ecs.DeregisterContainerInstanceInput, arg2 ...request.Option) (*ecs.DeregisterContainerInstanceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterContainerInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DeregisterContainerInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterContainerInstanceWithContext indicates an expected call of DeregisterContainerInstanceWithContext
func (mr *MockECSAPIMockRecorder) DeregisterContainerInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterContainerInstanceWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeregisterContainerInstanceWithContext), varargs...)
}

// DeregisterContainerInstanceRequest mocks base method
func (m *MockECSAPI) DeregisterContainerInstanceRequest(arg0 *ecs.DeregisterContainerInstanceInput) (*request.Request, *ecs.DeregisterContainerInstanceOutput) {
	ret := m.ctrl.Call(m, "DeregisterContainerInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DeregisterContainerInstanceOutput)
	return ret0, ret1
}

// DeregisterContainerInstanceRequest indicates an expected call of DeregisterContainerInstanceRequest
func (mr *MockECSAPIMockRecorder) DeregisterContainerInstanceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterContainerInstanceRequest", reflect.TypeOf((*MockECSAPI)(nil).DeregisterContainerInstanceRequest), arg0)
}

// DeregisterTaskDefinition mocks base method
func (m *MockECSAPI) DeregisterTaskDefinition(arg0 *ecs.DeregisterTaskDefinitionInput) (*ecs.DeregisterTaskDefinitionOutput, error) {
	ret := m.ctrl.Call(m, "DeregisterTaskDefinition", arg0)
	ret0, _ := ret[0].(*ecs.DeregisterTaskDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterTaskDefinition indicates an expected call of DeregisterTaskDefinition
func (mr *MockECSAPIMockRecorder) DeregisterTaskDefinition(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskDefinition", reflect.TypeOf((*MockECSAPI)(nil).DeregisterTaskDefinition), arg0)
}

// DeregisterTaskDefinitionWithContext mocks base method
func (m *MockECSAPI) DeregisterTaskDefinitionWithContext(arg0 aws.Context, arg1 *ecs.DeregisterTaskDefinitionInput, arg2 ...request.Option) (*ecs.DeregisterTaskDefinitionOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterTaskDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DeregisterTaskDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterTaskDefinitionWithContext indicates an expected call of DeregisterTaskDefinitionWithContext
func (mr *MockECSAPIMockRecorder) DeregisterTaskDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskDefinitionWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeregisterTaskDefinitionWithContext), varargs...)
}

// DeregisterTaskDefinitionRequest mocks base method
func (m *MockECSAPI) DeregisterTaskDefinitionRequest(arg0 *ecs.DeregisterTaskDefinitionInput) (*request.Request, *ecs.DeregisterTaskDefinitionOutput) {
	ret := m.ctrl.Call(m, "DeregisterTaskDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DeregisterTaskDefinitionOutput)
	return ret0, ret1
}

// DeregisterTaskDefinitionRequest indicates an expected call of DeregisterTaskDefinitionRequest
func (mr *MockECSAPIMockRecorder) DeregisterTaskDefinitionRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskDefinitionRequest", reflect.TypeOf((*MockECSAPI)(nil).DeregisterTaskDefinitionRequest), arg0)
}

// DescribeClusters mocks base method
func (m *MockECSAPI) DescribeClusters(arg0 *ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error) {
	ret := m.ctrl.Call(m, "DescribeClusters", arg0)
	ret0, _ := ret[0].(*ecs.DescribeClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClusters indicates an expected call of DescribeClusters
func (mr *MockECSAPIMockRecorder) DescribeClusters(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClusters", reflect.TypeOf((*MockECSAPI)(nil).DescribeClusters), arg0)
}

// DescribeClustersWithContext mocks base method
func (m *MockECSAPI) DescribeClustersWithContext(arg0 aws.Context, arg1 *ecs.DescribeClustersInput, arg2 ...request.Option) (*ecs.DescribeClustersOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClustersWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DescribeClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClustersWithContext indicates an expected call of DescribeClustersWithContext
func (mr *MockECSAPIMockRecorder) DescribeClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClustersWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeClustersWithContext), varargs...)
}

// DescribeClustersRequest mocks base method
func (m *MockECSAPI) DescribeClustersRequest(arg0 *ecs.DescribeClustersInput) (*request.Request, *ecs.DescribeClustersOutput) {
	ret := m.ctrl.Call(m, "DescribeClustersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DescribeClustersOutput)
	return ret0, ret1
}

// DescribeClustersRequest indicates an expected call of DescribeClustersRequest
func (mr *MockECSAPIMockRecorder) DescribeClustersRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClustersRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeClustersRequest), arg0)
}

// DescribeContainerInstances mocks base method
func (m *MockECSAPI) DescribeContainerInstances(arg0 *ecs.DescribeContainerInstancesInput) (*ecs.DescribeContainerInstancesOutput, error) {
	ret := m.ctrl.Call(m, "DescribeContainerInstances", arg0)
	ret0, _ := ret[0].(*ecs.DescribeContainerInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeContainerInstances indicates an expected call of DescribeContainerInstances
func (mr *MockECSAPIMockRecorder) DescribeContainerInstances(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerInstances", reflect.TypeOf((*MockECSAPI)(nil).DescribeContainerInstances), arg0)
}

// DescribeContainerInstancesWithContext mocks base method
func (m *MockECSAPI) DescribeContainerInstancesWithContext(arg0 aws.Context, arg1 *ecs.DescribeContainerInstancesInput, arg2 ...request.Option) (*ecs.DescribeContainerInstancesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeContainerInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DescribeContainerInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeContainerInstancesWithContext indicates an expected call of DescribeContainerInstancesWithContext
func (mr *MockECSAPIMockRecorder) DescribeContainerInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerInstancesWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeContainerInstancesWithContext), varargs...)
}

// DescribeContainerInstancesRequest mocks base method
func (m *MockECSAPI) DescribeContainerInstancesRequest(arg0 *ecs.DescribeContainerInstancesInput) (*request.Request, *ecs.DescribeContainerInstancesOutput) {
	ret := m.ctrl.Call(m, "DescribeContainerInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DescribeContainerInstancesOutput)
	return ret0, ret1
}

// DescribeContainerInstancesRequest indicates an expected call of DescribeContainerInstancesRequest
func (mr *MockECSAPIMockRecorder) DescribeContainerInstancesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerInstancesRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeContainerInstancesRequest), arg0)
}

// DescribeServices mocks base method
func (m *MockECSAPI) DescribeServices(arg0 *ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error) {
	ret := m.ctrl.Call(m, "DescribeServices", arg0)
	ret0, _ := ret[0].(*ecs.DescribeServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeServices indicates an expected call of DescribeServices
func (mr *MockECSAPIMockRecorder) DescribeServices(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServices", reflect.TypeOf((*MockECSAPI)(nil).DescribeServices), arg0)
}

// DescribeServicesWithContext mocks base method
func (m *MockECSAPI) DescribeServicesWithContext(arg0 aws.Context, arg1 *ecs.DescribeServicesInput, arg2 ...request.Option) (*ecs.DescribeServicesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeServicesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DescribeServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeServicesWithContext indicates an expected call of DescribeServicesWithContext
func (mr *MockECSAPIMockRecorder) DescribeServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServicesWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeServicesWithContext), varargs...)
}

// DescribeServicesRequest mocks base method
func (m *MockECSAPI) DescribeServicesRequest(arg0 *ecs.DescribeServicesInput) (*request.Request, *ecs.DescribeServicesOutput) {
	ret := m.ctrl.Call(m, "DescribeServicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DescribeServicesOutput)
	return ret0, ret1
}

// DescribeServicesRequest indicates an expected call of DescribeServicesRequest
func (mr *MockECSAPIMockRecorder) DescribeServicesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServicesRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeServicesRequest), arg0)
}

// DescribeTaskDefinition mocks base method
func (m *MockECSAPI) DescribeTaskDefinition(arg0 *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error) {
	ret := m.ctrl.Call(m, "DescribeTaskDefinition", arg0)
	ret0, _ := ret[0].(*ecs.DescribeTaskDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTaskDefinition indicates an expected call of DescribeTaskDefinition
func (mr *MockECSAPIMockRecorder) DescribeTaskDefinition(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskDefinition", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskDefinition), arg0)
}

// DescribeTaskDefinitionWithContext mocks base method
func (m *MockECSAPI) DescribeTaskDefinitionWithContext(arg0 aws.Context, arg1 *ecs.DescribeTaskDefinitionInput, arg2 ...request.Option) (*ecs.DescribeTaskDefinitionOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTaskDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DescribeTaskDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTaskDefinitionWithContext indicates an expected call of DescribeTaskDefinitionWithContext
func (mr *MockECSAPIMockRecorder) DescribeTaskDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskDefinitionWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskDefinitionWithContext), varargs...)
}

// DescribeTaskDefinitionRequest mocks base method
func (m *MockECSAPI) DescribeTaskDefinitionRequest(arg0 *ecs.DescribeTaskDefinitionInput) (*request.Request, *ecs.DescribeTaskDefinitionOutput) {
	ret := m.ctrl.Call(m, "DescribeTaskDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DescribeTaskDefinitionOutput)
	return ret0, ret1
}

// DescribeTaskDefinitionRequest indicates an expected call of DescribeTaskDefinitionRequest
func (mr *MockECSAPIMockRecorder) DescribeTaskDefinitionRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskDefinitionRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskDefinitionRequest), arg0)
}

// DescribeTasks mocks base method
func (m *MockECSAPI) DescribeTasks(arg0 *ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error) {
	ret := m.ctrl.Call(m, "DescribeTasks", arg0)
	ret0, _ := ret[0].(*ecs.DescribeTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTasks indicates an expected call of DescribeTasks
func (mr *MockECSAPIMockRecorder) DescribeTasks(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTasks", reflect.TypeOf((*MockECSAPI)(nil).DescribeTasks), arg0)
}

// DescribeTasksWithContext mocks base method
func (m *MockECSAPI) DescribeTasksWithContext(arg0 aws.Context, arg1 *ecs.DescribeTasksInput, arg2 ...request.Option) (*ecs.DescribeTasksOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DescribeTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTasksWithContext indicates an expected call of DescribeTasksWithContext
func (mr *MockECSAPIMockRecorder) DescribeTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTasksWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeTasksWithContext), varargs...)
}

// DescribeTasksRequest mocks base method
func (m *MockECSAPI) DescribeTasksRequest(arg0 *ecs.DescribeTasksInput) (*request.Request, *ecs.DescribeTasksOutput) {
	ret := m.ctrl.Call(m, "DescribeTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DescribeTasksOutput)
	return ret0, ret1
}

// DescribeTasksRequest indicates an expected call of DescribeTasksRequest
func (mr *MockECSAPIMockRecorder) DescribeTasksRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTasksRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeTasksRequest), arg0)
}

// DiscoverPollEndpoint mocks base method
func (m *MockECSAPI) DiscoverPollEndpoint(arg0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) {
	ret := m.ctrl.Call(m, "DiscoverPollEndpoint", arg0)
	ret0, _ := ret[0].(*ecs.DiscoverPollEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiscoverPollEndpoint indicates an expected call of DiscoverPollEndpoint
func (mr *MockECSAPIMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpoint), arg0)
}

// DiscoverPollEndpointWithContext mocks base method
func (m *MockECSAPI) DiscoverPollEndpointWithContext(arg0 aws.Context, arg1 *ecs.DiscoverPollEndpointInput, arg2 ...request.Option) (*ecs.DiscoverPollEndpointOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DiscoverPollEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.DiscoverPollEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiscoverPollEndpointWithContext indicates an expected call of DiscoverPollEndpointWithContext
func (mr *MockECSAPIMockRecorder) DiscoverPollEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpointWithContext", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpointWithContext), varargs...)
}

// DiscoverPollEndpointRequest mocks base method
func (m *MockECSAPI) DiscoverPollEndpointRequest(arg0 *ecs.DiscoverPollEndpointInput) (*request.Request, *ecs.DiscoverPollEndpointOutput) {
	ret := m.ctrl.Call(m, "DiscoverPollEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.DiscoverPollEndpointOutput)
	return ret0, ret1
}

// DiscoverPollEndpointRequest indicates an expected call of DiscoverPollEndpointRequest
func (mr *MockECSAPIMockRecorder) DiscoverPollEndpointRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpointRequest", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpointRequest), arg0)
}

// ListAttributes mocks base method
func (m *MockECSAPI) ListAttributes(arg0 *ecs.ListAttributesInput) (*ecs.ListAttributesOutput, error) {
	ret := m.ctrl.Call(m, "ListAttributes", arg0)
	ret0, _ := ret[0].(*ecs.ListAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAttributes indicates an expected call of ListAttributes
func (mr *MockECSAPIMockRecorder) ListAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttributes", reflect.TypeOf((*MockECSAPI)(nil).ListAttributes), arg0)
}

// ListAttributesWithContext mocks base method
func (m *MockECSAPI) ListAttributesWithContext(arg0 aws.Context, arg1 *ecs.ListAttributesInput, arg2 ...request.Option) (*ecs.ListAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAttributesWithContext indicates an expected call of ListAttributesWithContext
func (mr *MockECSAPIMockRecorder) ListAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttributesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListAttributesWithContext), varargs...)
}

// ListAttributesRequest mocks base method
func (m *MockECSAPI) ListAttributesRequest(arg0 *ecs.ListAttributesInput) (*request.Request, *ecs.ListAttributesOutput) {
	ret := m.ctrl.Call(m, "ListAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListAttributesOutput)
	return ret0, ret1
}

// ListAttributesRequest indicates an expected call of ListAttributesRequest
func (mr *MockECSAPIMockRecorder) ListAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttributesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListAttributesRequest), arg0)
}

// ListClusters mocks base method
func (m *MockECSAPI) ListClusters(arg0 *ecs.ListClustersInput) (*ecs.ListClustersOutput, error) {
	ret := m.ctrl.Call(m, "ListClusters", arg0)
	ret0, _ := ret[0].(*ecs.ListClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters
func (mr *MockECSAPIMockRecorder) ListClusters(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockECSAPI)(nil).ListClusters), arg0)
}

// ListClustersWithContext mocks base method
func (m *MockECSAPI) ListClustersWithContext(arg0 aws.Context, arg1 *ecs.ListClustersInput, arg2 ...request.Option) (*ecs.ListClustersOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClustersWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClustersWithContext indicates an expected call of ListClustersWithContext
func (mr *MockECSAPIMockRecorder) ListClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListClustersWithContext), varargs...)
}

// ListClustersRequest mocks base method
func (m *MockECSAPI) ListClustersRequest(arg0 *ecs.ListClustersInput) (*request.Request, *ecs.ListClustersOutput) {
	ret := m.ctrl.Call(m, "ListClustersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListClustersOutput)
	return ret0, ret1
}

// ListClustersRequest indicates an expected call of ListClustersRequest
func (mr *MockECSAPIMockRecorder) ListClustersRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersRequest", reflect.TypeOf((*MockECSAPI)(nil).ListClustersRequest), arg0)
}

// ListClustersPages mocks base method
func (m *MockECSAPI) ListClustersPages(arg0 *ecs.ListClustersInput, arg1 func(*ecs.ListClustersOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListClustersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListClustersPages indicates an expected call of ListClustersPages
func (mr *MockECSAPIMockRecorder) ListClustersPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersPages", reflect.TypeOf((*MockECSAPI)(nil).ListClustersPages), arg0, arg1)
}

// ListClustersPagesWithContext mocks base method
func (m *MockECSAPI) ListClustersPagesWithContext(arg0 aws.Context, arg1 *ecs.ListClustersInput, arg2 func(*ecs.ListClustersOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClustersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListClustersPagesWithContext indicates an expected call of ListClustersPagesWithContext
func (mr *MockECSAPIMockRecorder) ListClustersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListClustersPagesWithContext), varargs...)
}

// ListContainerInstances mocks base method
func (m *MockECSAPI) ListContainerInstances(arg0 *ecs.ListContainerInstancesInput) (*ecs.ListContainerInstancesOutput, error) {
	ret := m.ctrl.Call(m, "ListContainerInstances", arg0)
	ret0, _ := ret[0].(*ecs.ListContainerInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContainerInstances indicates an expected call of ListContainerInstances
func (mr *MockECSAPIMockRecorder) ListContainerInstances(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstances", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstances), arg0)
}

// ListContainerInstancesWithContext mocks base method
func (m *MockECSAPI) ListContainerInstancesWithContext(arg0 aws.Context, arg1 *ecs.ListContainerInstancesInput, arg2 ...request.Option) (*ecs.ListContainerInstancesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContainerInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListContainerInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContainerInstancesWithContext indicates an expected call of ListContainerInstancesWithContext
func (mr *MockECSAPIMockRecorder) ListContainerInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesWithContext), varargs...)
}

// ListContainerInstancesRequest mocks base method
func (m *MockECSAPI) ListContainerInstancesRequest(arg0 *ecs.ListContainerInstancesInput) (*request.Request, *ecs.ListContainerInstancesOutput) {
	ret := m.ctrl.Call(m, "ListContainerInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListContainerInstancesOutput)
	return ret0, ret1
}

// ListContainerInstancesRequest indicates an expected call of ListContainerInstancesRequest
func (mr *MockECSAPIMockRecorder) ListContainerInstancesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesRequest), arg0)
}

// ListContainerInstancesPages mocks base method
func (m *MockECSAPI) ListContainerInstancesPages(arg0 *ecs.ListContainerInstancesInput, arg1 func(*ecs.ListContainerInstancesOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListContainerInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListContainerInstancesPages indicates an expected call of ListContainerInstancesPages
func (mr *MockECSAPIMockRecorder) ListContainerInstancesPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesPages", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesPages), arg0, arg1)
}

// ListContainerInstancesPagesWithContext mocks base method
func (m *MockECSAPI) ListContainerInstancesPagesWithContext(arg0 aws.Context, arg1 *ecs.ListContainerInstancesInput, arg2 func(*ecs.ListContainerInstancesOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContainerInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListContainerInstancesPagesWithContext indicates an expected call of ListContainerInstancesPagesWithContext
func (mr *MockECSAPIMockRecorder) ListContainerInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesPagesWithContext), varargs...)
}

// ListServices mocks base method
func (m *MockECSAPI) ListServices(arg0 *ecs.ListServicesInput) (*ecs.ListServicesOutput, error) {
	ret := m.ctrl.Call(m, "ListServices", arg0)
	ret0, _ := ret[0].(*ecs.ListServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServices indicates an expected call of ListServices
func (mr *MockECSAPIMockRecorder) ListServices(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockECSAPI)(nil).ListServices), arg0)
}

// ListServicesWithContext mocks base method
func (m *MockECSAPI) ListServicesWithContext(arg0 aws.Context, arg1 *ecs.ListServicesInput, arg2 ...request.Option) (*ecs.ListServicesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListServicesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServicesWithContext indicates an expected call of ListServicesWithContext
func (mr *MockECSAPIMockRecorder) ListServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListServicesWithContext), varargs...)
}

// ListServicesRequest mocks base method
func (m *MockECSAPI) ListServicesRequest(arg0 *ecs.ListServicesInput) (*request.Request, *ecs.ListServicesOutput) {
	ret := m.ctrl.Call(m, "ListServicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListServicesOutput)
	return ret0, ret1
}

// ListServicesRequest indicates an expected call of ListServicesRequest
func (mr *MockECSAPIMockRecorder) ListServicesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListServicesRequest), arg0)
}

// ListServicesPages mocks base method
func (m *MockECSAPI) ListServicesPages(arg0 *ecs.ListServicesInput, arg1 func(*ecs.ListServicesOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListServicesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListServicesPages indicates an expected call of ListServicesPages
func (mr *MockECSAPIMockRecorder) ListServicesPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesPages", reflect.TypeOf((*MockECSAPI)(nil).ListServicesPages), arg0, arg1)
}

// ListServicesPagesWithContext mocks base method
func (m *MockECSAPI) ListServicesPagesWithContext(arg0 aws.Context, arg1 *ecs.ListServicesInput, arg2 func(*ecs.ListServicesOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListServicesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListServicesPagesWithContext indicates an expected call of ListServicesPagesWithContext
func (mr *MockECSAPIMockRecorder) ListServicesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListServicesPagesWithContext), varargs...)
}

// ListTaskDefinitionFamilies mocks base method
func (m *MockECSAPI) ListTaskDefinitionFamilies(arg0 *ecs.ListTaskDefinitionFamiliesInput) (*ecs.ListTaskDefinitionFamiliesOutput, error) {
	ret := m.ctrl.Call(m, "ListTaskDefinitionFamilies", arg0)
	ret0, _ := ret[0].(*ecs.ListTaskDefinitionFamiliesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskDefinitionFamilies indicates an expected call of ListTaskDefinitionFamilies
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamilies(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamilies", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamilies), arg0)
}

// ListTaskDefinitionFamiliesWithContext mocks base method
func (m *MockECSAPI) ListTaskDefinitionFamiliesWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionFamiliesInput, arg2 ...request.Option) (*ecs.ListTaskDefinitionFamiliesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListTaskDefinitionFamiliesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskDefinitionFamiliesWithContext indicates an expected call of ListTaskDefinitionFamiliesWithContext
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesWithContext), varargs...)
}

// ListTaskDefinitionFamiliesRequest mocks base method
func (m *MockECSAPI) ListTaskDefinitionFamiliesRequest(arg0 *ecs.ListTaskDefinitionFamiliesInput) (*request.Request, *ecs.ListTaskDefinitionFamiliesOutput) {
	ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListTaskDefinitionFamiliesOutput)
	return ret0, ret1
}

// ListTaskDefinitionFamiliesRequest indicates an expected call of ListTaskDefinitionFamiliesRequest
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesRequest), arg0)
}

// ListTaskDefinitionFamiliesPages mocks base method
func (m *MockECSAPI) ListTaskDefinitionFamiliesPages(arg0 *ecs.ListTaskDefinitionFamiliesInput, arg1 func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTaskDefinitionFamiliesPages indicates an expected call of ListTaskDefinitionFamiliesPages
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesPages", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesPages), arg0, arg1)
}

// ListTaskDefinitionFamiliesPagesWithContext mocks base method
func (m *MockECSAPI) ListTaskDefinitionFamiliesPagesWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionFamiliesInput, arg2 func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTaskDefinitionFamiliesPagesWithContext indicates an expected call of ListTaskDefinitionFamiliesPagesWithContext
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesPagesWithContext), varargs...)
}

// ListTaskDefinitions mocks base method
func (m *MockECSAPI) ListTaskDefinitions(arg0 *ecs.ListTaskDefinitionsInput) (*ecs.ListTaskDefinitionsOutput, error) {
	ret := m.ctrl.Call(m, "ListTaskDefinitions", arg0)
	ret0, _ := ret[0].(*ecs.ListTaskDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskDefinitions indicates an expected call of ListTaskDefinitions
func (mr *MockECSAPIMockRecorder) ListTaskDefinitions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitions", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitions), arg0)
}

// ListTaskDefinitionsWithContext mocks base method
func (m *MockECSAPI) ListTaskDefinitionsWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionsInput, arg2 ...request.Option) (*ecs.ListTaskDefinitionsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTaskDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListTaskDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskDefinitionsWithContext indicates an expected call of ListTaskDefinitionsWithContext
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsWithContext), varargs...)
}

// ListTaskDefinitionsRequest mocks base method
func (m *MockECSAPI) ListTaskDefinitionsRequest(arg0 *ecs.ListTaskDefinitionsInput) (*request.Request, *ecs.ListTaskDefinitionsOutput) {
	ret := m.ctrl.Call(m, "ListTaskDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListTaskDefinitionsOutput)
	return ret0, ret1
}

// ListTaskDefinitionsRequest indicates an expected call of ListTaskDefinitionsRequest
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsRequest), arg0)
}

// ListTaskDefinitionsPages mocks base method
func (m *MockECSAPI) ListTaskDefinitionsPages(arg0 *ecs.ListTaskDefinitionsInput, arg1 func(*ecs.ListTaskDefinitionsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListTaskDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTaskDefinitionsPages indicates an expected call of ListTaskDefinitionsPages
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsPages", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsPages), arg0, arg1)
}

// ListTaskDefinitionsPagesWithContext mocks base method
func (m *MockECSAPI) ListTaskDefinitionsPagesWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionsInput, arg2 func(*ecs.ListTaskDefinitionsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTaskDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTaskDefinitionsPagesWithContext indicates an expected call of ListTaskDefinitionsPagesWithContext
func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsPagesWithContext), varargs...)
}

// ListTasks mocks base method
func (m *MockECSAPI) ListTasks(arg0 *ecs.ListTasksInput) (*ecs.ListTasksOutput, error) {
	ret := m.ctrl.Call(m, "ListTasks", arg0)
	ret0, _ := ret[0].(*ecs.ListTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTasks indicates an expected call of ListTasks
func (mr *MockECSAPIMockRecorder) ListTasks(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasks", reflect.TypeOf((*MockECSAPI)(nil).ListTasks), arg0)
}

// ListTasksWithContext mocks base method
func (m *MockECSAPI) ListTasksWithContext(arg0 aws.Context, arg1 *ecs.ListTasksInput, arg2 ...request.Option) (*ecs.ListTasksOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.ListTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTasksWithContext indicates an expected call of ListTasksWithContext
func (mr *MockECSAPIMockRecorder) ListTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTasksWithContext), varargs...)
}

// ListTasksRequest mocks base method
func (m *MockECSAPI) ListTasksRequest(arg0 *ecs.ListTasksInput) (*request.Request, *ecs.ListTasksOutput) {
	ret := m.ctrl.Call(m, "ListTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.ListTasksOutput)
	return ret0, ret1
}

// ListTasksRequest indicates an expected call of ListTasksRequest
func (mr *MockECSAPIMockRecorder) ListTasksRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTasksRequest), arg0)
}

// ListTasksPages mocks base method
func (m *MockECSAPI) ListTasksPages(arg0 *ecs.ListTasksInput, arg1 func(*ecs.ListTasksOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListTasksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTasksPages indicates an expected call of ListTasksPages
func (mr *MockECSAPIMockRecorder) ListTasksPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksPages", reflect.TypeOf((*MockECSAPI)(nil).ListTasksPages), arg0, arg1)
}

// ListTasksPagesWithContext mocks base method
func (m *MockECSAPI) ListTasksPagesWithContext(arg0 aws.Context, arg1 *ecs.ListTasksInput, arg2 func(*ecs.ListTasksOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTasksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTasksPagesWithContext indicates an expected call of ListTasksPagesWithContext
func (mr *MockECSAPIMockRecorder) ListTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTasksPagesWithContext), varargs...)
}

// PutAttributes mocks base method
func (m *MockECSAPI) PutAttributes(arg0 *ecs.PutAttributesInput) (*ecs.PutAttributesOutput, error) {
	ret := m.ctrl.Call(m, "PutAttributes", arg0)
	ret0, _ := ret[0].(*ecs.PutAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutAttributes indicates an expected call of PutAttributes
func (mr *MockECSAPIMockRecorder) PutAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAttributes", reflect.TypeOf((*MockECSAPI)(nil).PutAttributes), arg0)
}

// PutAttributesWithContext mocks base method
func (m *MockECSAPI) PutAttributesWithContext(arg0 aws.Context, arg1 *ecs.PutAttributesInput, arg2 ...request.Option) (*ecs.PutAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.PutAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutAttributesWithContext indicates an expected call of PutAttributesWithContext
func (mr *MockECSAPIMockRecorder) PutAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAttributesWithContext", reflect.TypeOf((*MockECSAPI)(nil).PutAttributesWithContext), varargs...)
}

// PutAttributesRequest mocks base method
func (m *MockECSAPI) PutAttributesRequest(arg0 *ecs.PutAttributesInput) (*request.Request, *ecs.PutAttributesOutput) {
	ret := m.ctrl.Call(m, "PutAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.PutAttributesOutput)
	return ret0, ret1
}

// PutAttributesRequest indicates an expected call of PutAttributesRequest
func (mr *MockECSAPIMockRecorder) PutAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAttributesRequest", reflect.TypeOf((*MockECSAPI)(nil).PutAttributesRequest), arg0)
}

// RegisterContainerInstance mocks base method
func (m *MockECSAPI) RegisterContainerInstance(arg0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) {
	ret := m.ctrl.Call(m, "RegisterContainerInstance", arg0)
	ret0, _ := ret[0].(*ecs.RegisterContainerInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterContainerInstance indicates an expected call of RegisterContainerInstance
func (mr *MockECSAPIMockRecorder) RegisterContainerInstance(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstance", reflect.TypeOf((*MockECSAPI)(nil).RegisterContainerInstance), arg0)
}

// RegisterContainerInstanceWithContext mocks base method
func (m *MockECSAPI) RegisterContainerInstanceWithContext(arg0 aws.Context, arg1 *ecs.RegisterContainerInstanceInput, arg2 ...request.Option) (*ecs.RegisterContainerInstanceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterContainerInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.RegisterContainerInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterContainerInstanceWithContext indicates an expected call of RegisterContainerInstanceWithContext
func (mr *MockECSAPIMockRecorder) RegisterContainerInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstanceWithContext", reflect.TypeOf((*MockECSAPI)(nil).RegisterContainerInstanceWithContext), varargs...)
}

// RegisterContainerInstanceRequest mocks base method
func (m *MockECSAPI) RegisterContainerInstanceRequest(arg0 *ecs.RegisterContainerInstanceInput) (*request.Request, *ecs.RegisterContainerInstanceOutput) {
	ret := m.ctrl.Call(m, "RegisterContainerInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.RegisterContainerInstanceOutput)
	return ret0, ret1
}

// RegisterContainerInstanceRequest indicates an expected call of RegisterContainerInstanceRequest
func (mr *MockECSAPIMockRecorder) RegisterContainerInstanceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstanceRequest", reflect.TypeOf((*MockECSAPI)(nil).RegisterContainerInstanceRequest), arg0)
}

// RegisterTaskDefinition mocks base method
func (m *MockECSAPI) RegisterTaskDefinition(arg0 *ecs.RegisterTaskDefinitionInput) (*ecs.RegisterTaskDefinitionOutput, error) {
	ret := m.ctrl.Call(m, "RegisterTaskDefinition", arg0)
	ret0, _ := ret[0].(*ecs.RegisterTaskDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterTaskDefinition indicates an expected call of RegisterTaskDefinition
func (mr *MockECSAPIMockRecorder) RegisterTaskDefinition(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskDefinition", reflect.TypeOf((*MockECSAPI)(nil).RegisterTaskDefinition), arg0)
}

// RegisterTaskDefinitionWithContext mocks base method
func (m *MockECSAPI) RegisterTaskDefinitionWithContext(arg0 aws.Context, arg1 *ecs.RegisterTaskDefinitionInput, arg2 ...request.Option) (*ecs.RegisterTaskDefinitionOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterTaskDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.RegisterTaskDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterTaskDefinitionWithContext indicates an expected call of RegisterTaskDefinitionWithContext
func (mr *MockECSAPIMockRecorder) RegisterTaskDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskDefinitionWithContext", reflect.TypeOf((*MockECSAPI)(nil).RegisterTaskDefinitionWithContext), varargs...)
}

// RegisterTaskDefinitionRequest mocks base method
func (m *MockECSAPI) RegisterTaskDefinitionRequest(arg0 *ecs.RegisterTaskDefinitionInput) (*request.Request, *ecs.RegisterTaskDefinitionOutput) {
	ret := m.ctrl.Call(m, "RegisterTaskDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.RegisterTaskDefinitionOutput)
	return ret0, ret1
}

// RegisterTaskDefinitionRequest indicates an expected call of RegisterTaskDefinitionRequest
func (mr *MockECSAPIMockRecorder) RegisterTaskDefinitionRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskDefinitionRequest", reflect.TypeOf((*MockECSAPI)(nil).RegisterTaskDefinitionRequest), arg0)
}

// RunTask mocks base method
func (m *MockECSAPI) RunTask(arg0 *ecs.RunTaskInput) (*ecs.RunTaskOutput, error) {
	ret := m.ctrl.Call(m, "RunTask", arg0)
	ret0, _ := ret[0].(*ecs.RunTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunTask indicates an expected call of RunTask
func (mr *MockECSAPIMockRecorder) RunTask(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTask", reflect.TypeOf((*MockECSAPI)(nil).RunTask), arg0)
}

// RunTaskWithContext mocks base method
func (m *MockECSAPI) RunTaskWithContext(arg0 aws.Context, arg1 *ecs.RunTaskInput, arg2 ...request.Option) (*ecs.RunTaskOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.RunTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunTaskWithContext indicates an expected call of RunTaskWithContext
func (mr *MockECSAPIMockRecorder) RunTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTaskWithContext", reflect.TypeOf((*MockECSAPI)(nil).RunTaskWithContext), varargs...)
}

// RunTaskRequest mocks base method
func (m *MockECSAPI) RunTaskRequest(arg0 *ecs.RunTaskInput) (*request.Request, *ecs.RunTaskOutput) {
	ret := m.ctrl.Call(m, "RunTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.RunTaskOutput)
	return ret0, ret1
}

// RunTaskRequest indicates an expected call of RunTaskRequest
func (mr *MockECSAPIMockRecorder) RunTaskRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTaskRequest", reflect.TypeOf((*MockECSAPI)(nil).RunTaskRequest), arg0)
}

// StartTask mocks base method
func (m *MockECSAPI) StartTask(arg0 *ecs.StartTaskInput) (*ecs.StartTaskOutput, error) {
	ret := m.ctrl.Call(m, "StartTask", arg0)
	ret0, _ := ret[0].(*ecs.StartTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartTask indicates an expected call of StartTask
func (mr *MockECSAPIMockRecorder) StartTask(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTask", reflect.TypeOf((*MockECSAPI)(nil).StartTask), arg0)
}

// StartTaskWithContext mocks base method
func (m *MockECSAPI) StartTaskWithContext(arg0 aws.Context, arg1 *ecs.StartTaskInput, arg2 ...request.Option) (*ecs.StartTaskOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.StartTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartTaskWithContext indicates an expected call of StartTaskWithContext
func (mr *MockECSAPIMockRecorder) StartTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTaskWithContext", reflect.TypeOf((*MockECSAPI)(nil).StartTaskWithContext), varargs...)
}

// StartTaskRequest mocks base method
func (m *MockECSAPI) StartTaskRequest(arg0 *ecs.StartTaskInput) (*request.Request, *ecs.StartTaskOutput) {
	ret := m.ctrl.Call(m, "StartTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.StartTaskOutput)
	return ret0, ret1
}

// StartTaskRequest indicates an expected call of StartTaskRequest
func (mr *MockECSAPIMockRecorder) StartTaskRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTaskRequest", reflect.TypeOf((*MockECSAPI)(nil).StartTaskRequest), arg0)
}

// StopTask mocks base method
func (m *MockECSAPI) StopTask(arg0 *ecs.StopTaskInput) (*ecs.StopTaskOutput, error) {
	ret := m.ctrl.Call(m, "StopTask", arg0)
	ret0, _ := ret[0].(*ecs.StopTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopTask indicates an expected call of StopTask
func (mr *MockECSAPIMockRecorder) StopTask(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTask", reflect.TypeOf((*MockECSAPI)(nil).StopTask), arg0)
}

// StopTaskWithContext mocks base method
func (m *MockECSAPI) StopTaskWithContext(arg0 aws.Context, arg1 *ecs.StopTaskInput, arg2 ...request.Option) (*ecs.StopTaskOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.StopTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopTaskWithContext indicates an expected call of StopTaskWithContext
func (mr *MockECSAPIMockRecorder) StopTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTaskWithContext", reflect.TypeOf((*MockECSAPI)(nil).StopTaskWithContext), varargs...)
}

// StopTaskRequest mocks base method
func (m *MockECSAPI) StopTaskRequest(arg0 *ecs.StopTaskInput) (*request.Request, *ecs.StopTaskOutput) {
	ret := m.ctrl.Call(m, "StopTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.StopTaskOutput)
	return ret0, ret1
}

// StopTaskRequest indicates an expected call of StopTaskRequest
func (mr *MockECSAPIMockRecorder) StopTaskRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTaskRequest", reflect.TypeOf((*MockECSAPI)(nil).StopTaskRequest), arg0)
}

// SubmitContainerStateChange mocks base method
func (m *MockECSAPI) SubmitContainerStateChange(arg0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) {
	ret := m.ctrl.Call(m, "SubmitContainerStateChange", arg0)
	ret0, _ := ret[0].(*ecs.SubmitContainerStateChangeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitContainerStateChange indicates an expected call of SubmitContainerStateChange
func (mr *MockECSAPIMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSAPI)(nil).SubmitContainerStateChange), arg0)
}

// SubmitContainerStateChangeWithContext mocks base method
func (m *MockECSAPI) SubmitContainerStateChangeWithContext(arg0 aws.Context, arg1 *ecs.SubmitContainerStateChangeInput, arg2 ...request.Option) (*ecs.SubmitContainerStateChangeOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubmitContainerStateChangeWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.SubmitContainerStateChangeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitContainerStateChangeWithContext indicates an expected call of SubmitContainerStateChangeWithContext
func (mr *MockECSAPIMockRecorder) SubmitContainerStateChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChangeWithContext", reflect.TypeOf((*MockECSAPI)(nil).SubmitContainerStateChangeWithContext), varargs...)
}

// SubmitContainerStateChangeRequest mocks base method
func (m *MockECSAPI) SubmitContainerStateChangeRequest(arg0 *ecs.SubmitContainerStateChangeInput) (*request.Request, *ecs.SubmitContainerStateChangeOutput) {
	ret := m.ctrl.Call(m, "SubmitContainerStateChangeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.SubmitContainerStateChangeOutput)
	return ret0, ret1
}

// SubmitContainerStateChangeRequest indicates an expected call of SubmitContainerStateChangeRequest
func (mr *MockECSAPIMockRecorder) SubmitContainerStateChangeRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChangeRequest", reflect.TypeOf((*MockECSAPI)(nil).SubmitContainerStateChangeRequest), arg0)
}

// SubmitTaskStateChange mocks base method
func (m *MockECSAPI) SubmitTaskStateChange(arg0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) {
	ret := m.ctrl.Call(m, "SubmitTaskStateChange", arg0)
	ret0, _ := ret[0].(*ecs.SubmitTaskStateChangeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitTaskStateChange indicates an expected call of SubmitTaskStateChange
func (mr *MockECSAPIMockRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChange", reflect.TypeOf((*MockECSAPI)(nil).SubmitTaskStateChange), arg0)
}

// SubmitTaskStateChangeWithContext mocks base method
func (m *MockECSAPI) SubmitTaskStateChangeWithContext(arg0 aws.Context, arg1 *ecs.SubmitTaskStateChangeInput, arg2 ...request.Option) (*ecs.SubmitTaskStateChangeOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubmitTaskStateChangeWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.SubmitTaskStateChangeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitTaskStateChangeWithContext indicates an expected call of SubmitTaskStateChangeWithContext
func (mr *MockECSAPIMockRecorder) SubmitTaskStateChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChangeWithContext", reflect.TypeOf((*MockECSAPI)(nil).SubmitTaskStateChangeWithContext), varargs...)
}

// SubmitTaskStateChangeRequest mocks base method
func (m *MockECSAPI) SubmitTaskStateChangeRequest(arg0 *ecs.SubmitTaskStateChangeInput) (*request.Request, *ecs.SubmitTaskStateChangeOutput) {
	ret := m.ctrl.Call(m, "SubmitTaskStateChangeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.SubmitTaskStateChangeOutput)
	return ret0, ret1
}

// SubmitTaskStateChangeRequest indicates an expected call of SubmitTaskStateChangeRequest
func (mr *MockECSAPIMockRecorder) SubmitTaskStateChangeRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChangeRequest", reflect.TypeOf((*MockECSAPI)(nil).SubmitTaskStateChangeRequest), arg0)
}

// UpdateContainerAgent mocks base method
func (m *MockECSAPI) UpdateContainerAgent(arg0 *ecs.UpdateContainerAgentInput) (*ecs.UpdateContainerAgentOutput, error) {
	ret := m.ctrl.Call(m, "UpdateContainerAgent", arg0)
	ret0, _ := ret[0].(*ecs.UpdateContainerAgentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContainerAgent indicates an expected call of UpdateContainerAgent
func (mr *MockECSAPIMockRecorder) UpdateContainerAgent(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerAgent", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerAgent), arg0)
}

// UpdateContainerAgentWithContext mocks base method
func (m *MockECSAPI) UpdateContainerAgentWithContext(arg0 aws.Context, arg1 *ecs.UpdateContainerAgentInput, arg2 ...request.Option) (*ecs.UpdateContainerAgentOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateContainerAgentWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.UpdateContainerAgentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContainerAgentWithContext indicates an expected call of UpdateContainerAgentWithContext
func (mr *MockECSAPIMockRecorder) UpdateContainerAgentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerAgentWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerAgentWithContext), varargs...)
}

// UpdateContainerAgentRequest mocks base method
func (m *MockECSAPI) UpdateContainerAgentRequest(arg0 *ecs.UpdateContainerAgentInput) (*request.Request, *ecs.UpdateContainerAgentOutput) {
	ret := m.ctrl.Call(m, "UpdateContainerAgentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.UpdateContainerAgentOutput)
	return ret0, ret1
}

// UpdateContainerAgentRequest indicates an expected call of UpdateContainerAgentRequest
func (mr *MockECSAPIMockRecorder) UpdateContainerAgentRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerAgentRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerAgentRequest), arg0)
}

// UpdateContainerInstancesState mocks base method
func (m *MockECSAPI) UpdateContainerInstancesState(arg0 *ecs.UpdateContainerInstancesStateInput) (*ecs.UpdateContainerInstancesStateOutput, error) {
	ret := m.ctrl.Call(m, "UpdateContainerInstancesState", arg0)
	ret0, _ := ret[0].(*ecs.UpdateContainerInstancesStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContainerInstancesState indicates an expected call of UpdateContainerInstancesState
func (mr *MockECSAPIMockRecorder) UpdateContainerInstancesState(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerInstancesState", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerInstancesState), arg0)
}

// UpdateContainerInstancesStateWithContext mocks base method
func (m *MockECSAPI) UpdateContainerInstancesStateWithContext(arg0 aws.Context, arg1 *ecs.UpdateContainerInstancesStateInput, arg2 ...request.Option) (*ecs.UpdateContainerInstancesStateOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateContainerInstancesStateWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.UpdateContainerInstancesStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContainerInstancesStateWithContext indicates an expected call of UpdateContainerInstancesStateWithContext
func (mr *MockECSAPIMockRecorder) UpdateContainerInstancesStateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerInstancesStateWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerInstancesStateWithContext), varargs...)
}

// UpdateContainerInstancesStateRequest mocks base method
func (m *MockECSAPI) UpdateContainerInstancesStateRequest(arg0 *ecs.UpdateContainerInstancesStateInput) (*request.Request, *ecs.UpdateContainerInstancesStateOutput) {
	ret := m.ctrl.Call(m, "UpdateContainerInstancesStateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.UpdateContainerInstancesStateOutput)
	return ret0, ret1
}

// UpdateContainerInstancesStateRequest indicates an expected call of UpdateContainerInstancesStateRequest
func (mr *MockECSAPIMockRecorder) UpdateContainerInstancesStateRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerInstancesStateRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerInstancesStateRequest), arg0)
}

// UpdateService mocks base method
func (m *MockECSAPI) UpdateService(arg0 *ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error) {
	ret := m.ctrl.Call(m, "UpdateService", arg0)
	ret0, _ := ret[0].(*ecs.UpdateServiceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateService indicates an expected call of UpdateService
func (mr *MockECSAPIMockRecorder) UpdateService(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockECSAPI)(nil).UpdateService), arg0)
}

// UpdateServiceWithContext mocks base method
func (m *MockECSAPI) UpdateServiceWithContext(arg0 aws.Context, arg1 *ecs.UpdateServiceInput, arg2 ...request.Option) (*ecs.UpdateServiceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateServiceWithContext", varargs...)
	ret0, _ := ret[0].(*ecs.UpdateServiceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServiceWithContext indicates an expected call of UpdateServiceWithContext
func (mr *MockECSAPIMockRecorder) UpdateServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateServiceWithContext), varargs...)
}

// UpdateServiceRequest mocks base method
func (m *MockECSAPI) UpdateServiceRequest(arg0 *ecs.UpdateServiceInput) (*request.Request, *ecs.UpdateServiceOutput) {
	ret := m.ctrl.Call(m, "UpdateServiceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ecs.UpdateServiceOutput)
	return ret0, ret1
}

// UpdateServiceRequest indicates an expected call of UpdateServiceRequest
func (mr *MockECSAPIMockRecorder) UpdateServiceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateServiceRequest), arg0)
}

// WaitUntilServicesInactive mocks base method
func (m *MockECSAPI) WaitUntilServicesInactive(arg0 *ecs.DescribeServicesInput) error {
	ret := m.ctrl.Call(m, "WaitUntilServicesInactive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilServicesInactive indicates an expected call of WaitUntilServicesInactive
func (mr *MockECSAPIMockRecorder) WaitUntilServicesInactive(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesInactive", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesInactive), arg0)
}

// WaitUntilServicesInactiveWithContext mocks base method
func (m *MockECSAPI) WaitUntilServicesInactiveWithContext(arg0 aws.Context, arg1 *ecs.DescribeServicesInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilServicesInactiveWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilServicesInactiveWithContext indicates an expected call of WaitUntilServicesInactiveWithContext
func (mr *MockECSAPIMockRecorder) WaitUntilServicesInactiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesInactiveWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesInactiveWithContext), varargs...)
}

// WaitUntilServicesStable mocks base method
func (m *MockECSAPI) WaitUntilServicesStable(arg0 *ecs.DescribeServicesInput) error {
	ret := m.ctrl.Call(m, "WaitUntilServicesStable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilServicesStable indicates an expected call of WaitUntilServicesStable
func (mr *MockECSAPIMockRecorder) WaitUntilServicesStable(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesStable", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesStable), arg0)
}

// WaitUntilServicesStableWithContext mocks base method
func (m *MockECSAPI) WaitUntilServicesStableWithContext(arg0 aws.Context, arg1 *ecs.DescribeServicesInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilServicesStableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilServicesStableWithContext indicates an expected call of WaitUntilServicesStableWithContext
func (mr *MockECSAPIMockRecorder) WaitUntilServicesStableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesStableWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesStableWithContext), varargs...)
}

// WaitUntilTasksRunning mocks base method
func (m *MockECSAPI) WaitUntilTasksRunning(arg0 *ecs.DescribeTasksInput) error {
	ret := m.ctrl.Call(m, "WaitUntilTasksRunning", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTasksRunning indicates an expected call of WaitUntilTasksRunning
func (mr *MockECSAPIMockRecorder) WaitUntilTasksRunning(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksRunning", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksRunning), arg0)
}

// WaitUntilTasksRunningWithContext mocks base method
func (m *MockECSAPI) WaitUntilTasksRunningWithContext(arg0 aws.Context, arg1 *ecs.DescribeTasksInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilTasksRunningWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTasksRunningWithContext indicates an expected call of WaitUntilTasksRunningWithContext
func (mr *MockECSAPIMockRecorder) WaitUntilTasksRunningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksRunningWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksRunningWithContext), varargs...)
}

// WaitUntilTasksStopped mocks base method
func (m *MockECSAPI) WaitUntilTasksStopped(arg0 *ecs.DescribeTasksInput) error {
	ret := m.ctrl.Call(m, "WaitUntilTasksStopped", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTasksStopped indicates an expected call of WaitUntilTasksStopped
func (mr *MockECSAPIMockRecorder) WaitUntilTasksStopped(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksStopped", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksStopped), arg0)
}

// WaitUntilTasksStoppedWithContext mocks base method
func (m *MockECSAPI) WaitUntilTasksStoppedWithContext(arg0 aws.Context, arg1 *ecs.DescribeTasksInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilTasksStoppedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTasksStoppedWithContext indicates an expected call of WaitUntilTasksStoppedWithContext
func (mr *MockECSAPIMockRecorder) WaitUntilTasksStoppedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksStoppedWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksStoppedWithContext), varargs...)
}