// Code generated by mockery v1.0.0. DO NOT EDIT.

// Code generated DO NOT EDIT

package awsmocks

import aws "github.com/aws/aws-sdk-go/aws"
import ecs "github.com/aws/aws-sdk-go/service/ecs"

import mock "github.com/stretchr/testify/mock"
import request "github.com/aws/aws-sdk-go/aws/request"

// ECSAPI is an autogenerated mock type for the ECSAPI type
type ECSAPI struct {
	mock.Mock
}

// CreateCluster provides a mock function with given fields: _a0
func (_m *ECSAPI) CreateCluster(_a0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.CreateClusterOutput
	if rf, ok := ret.Get(0).(func(*ecs.CreateClusterInput) *ecs.CreateClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.CreateClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.CreateClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateClusterRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) CreateClusterRequest(_a0 *ecs.CreateClusterInput) (*request.Request, *ecs.CreateClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.CreateClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.CreateClusterOutput
	if rf, ok := ret.Get(1).(func(*ecs.CreateClusterInput) *ecs.CreateClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.CreateClusterOutput)
		}
	}

	return r0, r1
}

// CreateClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) CreateClusterWithContext(_a0 aws.Context, _a1 *ecs.CreateClusterInput, _a2 ...request.Option) (*ecs.CreateClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.CreateClusterOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.CreateClusterInput, ...request.Option) *ecs.CreateClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.CreateClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.CreateClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateService provides a mock function with given fields: _a0
func (_m *ECSAPI) CreateService(_a0 *ecs.CreateServiceInput) (*ecs.CreateServiceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.CreateServiceOutput
	if rf, ok := ret.Get(0).(func(*ecs.CreateServiceInput) *ecs.CreateServiceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.CreateServiceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.CreateServiceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateServiceRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) CreateServiceRequest(_a0 *ecs.CreateServiceInput) (*request.Request, *ecs.CreateServiceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.CreateServiceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.CreateServiceOutput
	if rf, ok := ret.Get(1).(func(*ecs.CreateServiceInput) *ecs.CreateServiceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.CreateServiceOutput)
		}
	}

	return r0, r1
}

// CreateServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) CreateServiceWithContext(_a0 aws.Context, _a1 *ecs.CreateServiceInput, _a2 ...request.Option) (*ecs.CreateServiceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.CreateServiceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.CreateServiceInput, ...request.Option) *ecs.CreateServiceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.CreateServiceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.CreateServiceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAttributes provides a mock function with given fields: _a0
func (_m *ECSAPI) DeleteAttributes(_a0 *ecs.DeleteAttributesInput) (*ecs.DeleteAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DeleteAttributesOutput
	if rf, ok := ret.Get(0).(func(*ecs.DeleteAttributesInput) *ecs.DeleteAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeleteAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DeleteAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAttributesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DeleteAttributesRequest(_a0 *ecs.DeleteAttributesInput) (*request.Request, *ecs.DeleteAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DeleteAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DeleteAttributesOutput
	if rf, ok := ret.Get(1).(func(*ecs.DeleteAttributesInput) *ecs.DeleteAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DeleteAttributesOutput)
		}
	}

	return r0, r1
}

// DeleteAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DeleteAttributesWithContext(_a0 aws.Context, _a1 *ecs.DeleteAttributesInput, _a2 ...request.Option) (*ecs.DeleteAttributesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DeleteAttributesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DeleteAttributesInput, ...request.Option) *ecs.DeleteAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeleteAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DeleteAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCluster provides a mock function with given fields: _a0
func (_m *ECSAPI) DeleteCluster(_a0 *ecs.DeleteClusterInput) (*ecs.DeleteClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DeleteClusterOutput
	if rf, ok := ret.Get(0).(func(*ecs.DeleteClusterInput) *ecs.DeleteClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeleteClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DeleteClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteClusterRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DeleteClusterRequest(_a0 *ecs.DeleteClusterInput) (*request.Request, *ecs.DeleteClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DeleteClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DeleteClusterOutput
	if rf, ok := ret.Get(1).(func(*ecs.DeleteClusterInput) *ecs.DeleteClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DeleteClusterOutput)
		}
	}

	return r0, r1
}

// DeleteClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DeleteClusterWithContext(_a0 aws.Context, _a1 *ecs.DeleteClusterInput, _a2 ...request.Option) (*ecs.DeleteClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DeleteClusterOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DeleteClusterInput, ...request.Option) *ecs.DeleteClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeleteClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DeleteClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteService provides a mock function with given fields: _a0
func (_m *ECSAPI) DeleteService(_a0 *ecs.DeleteServiceInput) (*ecs.DeleteServiceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DeleteServiceOutput
	if rf, ok := ret.Get(0).(func(*ecs.DeleteServiceInput) *ecs.DeleteServiceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeleteServiceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DeleteServiceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServiceRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DeleteServiceRequest(_a0 *ecs.DeleteServiceInput) (*request.Request, *ecs.DeleteServiceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DeleteServiceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DeleteServiceOutput
	if rf, ok := ret.Get(1).(func(*ecs.DeleteServiceInput) *ecs.DeleteServiceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DeleteServiceOutput)
		}
	}

	return r0, r1
}

// DeleteServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DeleteServiceWithContext(_a0 aws.Context, _a1 *ecs.DeleteServiceInput, _a2 ...request.Option) (*ecs.DeleteServiceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DeleteServiceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DeleteServiceInput, ...request.Option) *ecs.DeleteServiceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeleteServiceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DeleteServiceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterContainerInstance provides a mock function with given fields: _a0
func (_m *ECSAPI) DeregisterContainerInstance(_a0 *ecs.DeregisterContainerInstanceInput) (*ecs.DeregisterContainerInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DeregisterContainerInstanceOutput
	if rf, ok := ret.Get(0).(func(*ecs.DeregisterContainerInstanceInput) *ecs.DeregisterContainerInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeregisterContainerInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DeregisterContainerInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterContainerInstanceRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DeregisterContainerInstanceRequest(_a0 *ecs.DeregisterContainerInstanceInput) (*request.Request, *ecs.DeregisterContainerInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DeregisterContainerInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DeregisterContainerInstanceOutput
	if rf, ok := ret.Get(1).(func(*ecs.DeregisterContainerInstanceInput) *ecs.DeregisterContainerInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DeregisterContainerInstanceOutput)
		}
	}

	return r0, r1
}

// DeregisterContainerInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DeregisterContainerInstanceWithContext(_a0 aws.Context, _a1 *ecs.DeregisterContainerInstanceInput, _a2 ...request.Option) (*ecs.DeregisterContainerInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DeregisterContainerInstanceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DeregisterContainerInstanceInput, ...request.Option) *ecs.DeregisterContainerInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeregisterContainerInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DeregisterContainerInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterTaskDefinition provides a mock function with given fields: _a0
func (_m *ECSAPI) DeregisterTaskDefinition(_a0 *ecs.DeregisterTaskDefinitionInput) (*ecs.DeregisterTaskDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DeregisterTaskDefinitionOutput
	if rf, ok := ret.Get(0).(func(*ecs.DeregisterTaskDefinitionInput) *ecs.DeregisterTaskDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeregisterTaskDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DeregisterTaskDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterTaskDefinitionRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DeregisterTaskDefinitionRequest(_a0 *ecs.DeregisterTaskDefinitionInput) (*request.Request, *ecs.DeregisterTaskDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DeregisterTaskDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DeregisterTaskDefinitionOutput
	if rf, ok := ret.Get(1).(func(*ecs.DeregisterTaskDefinitionInput) *ecs.DeregisterTaskDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DeregisterTaskDefinitionOutput)
		}
	}

	return r0, r1
}

// DeregisterTaskDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DeregisterTaskDefinitionWithContext(_a0 aws.Context, _a1 *ecs.DeregisterTaskDefinitionInput, _a2 ...request.Option) (*ecs.DeregisterTaskDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DeregisterTaskDefinitionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DeregisterTaskDefinitionInput, ...request.Option) *ecs.DeregisterTaskDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DeregisterTaskDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DeregisterTaskDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeClusters provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeClusters(_a0 *ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DescribeClustersOutput
	if rf, ok := ret.Get(0).(func(*ecs.DescribeClustersInput) *ecs.DescribeClustersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DescribeClustersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeClustersRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeClustersRequest(_a0 *ecs.DescribeClustersInput) (*request.Request, *ecs.DescribeClustersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DescribeClustersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DescribeClustersOutput
	if rf, ok := ret.Get(1).(func(*ecs.DescribeClustersInput) *ecs.DescribeClustersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DescribeClustersOutput)
		}
	}

	return r0, r1
}

// DescribeClustersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DescribeClustersWithContext(_a0 aws.Context, _a1 *ecs.DescribeClustersInput, _a2 ...request.Option) (*ecs.DescribeClustersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DescribeClustersOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeClustersInput, ...request.Option) *ecs.DescribeClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DescribeClustersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContainerInstances provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeContainerInstances(_a0 *ecs.DescribeContainerInstancesInput) (*ecs.DescribeContainerInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DescribeContainerInstancesOutput
	if rf, ok := ret.Get(0).(func(*ecs.DescribeContainerInstancesInput) *ecs.DescribeContainerInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeContainerInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DescribeContainerInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContainerInstancesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeContainerInstancesRequest(_a0 *ecs.DescribeContainerInstancesInput) (*request.Request, *ecs.DescribeContainerInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DescribeContainerInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DescribeContainerInstancesOutput
	if rf, ok := ret.Get(1).(func(*ecs.DescribeContainerInstancesInput) *ecs.DescribeContainerInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DescribeContainerInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeContainerInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DescribeContainerInstancesWithContext(_a0 aws.Context, _a1 *ecs.DescribeContainerInstancesInput, _a2 ...request.Option) (*ecs.DescribeContainerInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DescribeContainerInstancesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeContainerInstancesInput, ...request.Option) *ecs.DescribeContainerInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeContainerInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DescribeContainerInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeServices provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeServices(_a0 *ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DescribeServicesOutput
	if rf, ok := ret.Get(0).(func(*ecs.DescribeServicesInput) *ecs.DescribeServicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DescribeServicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeServicesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeServicesRequest(_a0 *ecs.DescribeServicesInput) (*request.Request, *ecs.DescribeServicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DescribeServicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DescribeServicesOutput
	if rf, ok := ret.Get(1).(func(*ecs.DescribeServicesInput) *ecs.DescribeServicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DescribeServicesOutput)
		}
	}

	return r0, r1
}

// DescribeServicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DescribeServicesWithContext(_a0 aws.Context, _a1 *ecs.DescribeServicesInput, _a2 ...request.Option) (*ecs.DescribeServicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DescribeServicesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeServicesInput, ...request.Option) *ecs.DescribeServicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DescribeServicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTaskDefinition provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeTaskDefinition(_a0 *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DescribeTaskDefinitionOutput
	if rf, ok := ret.Get(0).(func(*ecs.DescribeTaskDefinitionInput) *ecs.DescribeTaskDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeTaskDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DescribeTaskDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTaskDefinitionRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeTaskDefinitionRequest(_a0 *ecs.DescribeTaskDefinitionInput) (*request.Request, *ecs.DescribeTaskDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DescribeTaskDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DescribeTaskDefinitionOutput
	if rf, ok := ret.Get(1).(func(*ecs.DescribeTaskDefinitionInput) *ecs.DescribeTaskDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DescribeTaskDefinitionOutput)
		}
	}

	return r0, r1
}

// DescribeTaskDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DescribeTaskDefinitionWithContext(_a0 aws.Context, _a1 *ecs.DescribeTaskDefinitionInput, _a2 ...request.Option) (*ecs.DescribeTaskDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DescribeTaskDefinitionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeTaskDefinitionInput, ...request.Option) *ecs.DescribeTaskDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeTaskDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DescribeTaskDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTasks provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeTasks(_a0 *ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DescribeTasksOutput
	if rf, ok := ret.Get(0).(func(*ecs.DescribeTasksInput) *ecs.DescribeTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DescribeTasksInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTasksRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DescribeTasksRequest(_a0 *ecs.DescribeTasksInput) (*request.Request, *ecs.DescribeTasksOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DescribeTasksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DescribeTasksOutput
	if rf, ok := ret.Get(1).(func(*ecs.DescribeTasksInput) *ecs.DescribeTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DescribeTasksOutput)
		}
	}

	return r0, r1
}

// DescribeTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DescribeTasksWithContext(_a0 aws.Context, _a1 *ecs.DescribeTasksInput, _a2 ...request.Option) (*ecs.DescribeTasksOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DescribeTasksOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeTasksInput, ...request.Option) *ecs.DescribeTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DescribeTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DescribeTasksInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DiscoverPollEndpoint provides a mock function with given fields: _a0
func (_m *ECSAPI) DiscoverPollEndpoint(_a0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.DiscoverPollEndpointOutput
	if rf, ok := ret.Get(0).(func(*ecs.DiscoverPollEndpointInput) *ecs.DiscoverPollEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DiscoverPollEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.DiscoverPollEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DiscoverPollEndpointRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) DiscoverPollEndpointRequest(_a0 *ecs.DiscoverPollEndpointInput) (*request.Request, *ecs.DiscoverPollEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.DiscoverPollEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.DiscoverPollEndpointOutput
	if rf, ok := ret.Get(1).(func(*ecs.DiscoverPollEndpointInput) *ecs.DiscoverPollEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.DiscoverPollEndpointOutput)
		}
	}

	return r0, r1
}

// DiscoverPollEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) DiscoverPollEndpointWithContext(_a0 aws.Context, _a1 *ecs.DiscoverPollEndpointInput, _a2 ...request.Option) (*ecs.DiscoverPollEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.DiscoverPollEndpointOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DiscoverPollEndpointInput, ...request.Option) *ecs.DiscoverPollEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.DiscoverPollEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.DiscoverPollEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttributes provides a mock function with given fields: _a0
func (_m *ECSAPI) ListAttributes(_a0 *ecs.ListAttributesInput) (*ecs.ListAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListAttributesOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListAttributesInput) *ecs.ListAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttributesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListAttributesRequest(_a0 *ecs.ListAttributesInput) (*request.Request, *ecs.ListAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListAttributesOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListAttributesInput) *ecs.ListAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListAttributesOutput)
		}
	}

	return r0, r1
}

// ListAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListAttributesWithContext(_a0 aws.Context, _a1 *ecs.ListAttributesInput, _a2 ...request.Option) (*ecs.ListAttributesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListAttributesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListAttributesInput, ...request.Option) *ecs.ListAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListClusters provides a mock function with given fields: _a0
func (_m *ECSAPI) ListClusters(_a0 *ecs.ListClustersInput) (*ecs.ListClustersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListClustersOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListClustersInput) *ecs.ListClustersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListClustersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListClustersPages provides a mock function with given fields: _a0, _a1
func (_m *ECSAPI) ListClustersPages(_a0 *ecs.ListClustersInput, _a1 func(*ecs.ListClustersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.ListClustersInput, func(*ecs.ListClustersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListClustersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECSAPI) ListClustersPagesWithContext(_a0 aws.Context, _a1 *ecs.ListClustersInput, _a2 func(*ecs.ListClustersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListClustersInput, func(*ecs.ListClustersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListClustersRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListClustersRequest(_a0 *ecs.ListClustersInput) (*request.Request, *ecs.ListClustersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListClustersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListClustersOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListClustersInput) *ecs.ListClustersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListClustersOutput)
		}
	}

	return r0, r1
}

// ListClustersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListClustersWithContext(_a0 aws.Context, _a1 *ecs.ListClustersInput, _a2 ...request.Option) (*ecs.ListClustersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListClustersOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListClustersInput, ...request.Option) *ecs.ListClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListClustersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListContainerInstances provides a mock function with given fields: _a0
func (_m *ECSAPI) ListContainerInstances(_a0 *ecs.ListContainerInstancesInput) (*ecs.ListContainerInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListContainerInstancesOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListContainerInstancesInput) *ecs.ListContainerInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListContainerInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListContainerInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListContainerInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *ECSAPI) ListContainerInstancesPages(_a0 *ecs.ListContainerInstancesInput, _a1 func(*ecs.ListContainerInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.ListContainerInstancesInput, func(*ecs.ListContainerInstancesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListContainerInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECSAPI) ListContainerInstancesPagesWithContext(_a0 aws.Context, _a1 *ecs.ListContainerInstancesInput, _a2 func(*ecs.ListContainerInstancesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListContainerInstancesInput, func(*ecs.ListContainerInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListContainerInstancesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListContainerInstancesRequest(_a0 *ecs.ListContainerInstancesInput) (*request.Request, *ecs.ListContainerInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListContainerInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListContainerInstancesOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListContainerInstancesInput) *ecs.ListContainerInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListContainerInstancesOutput)
		}
	}

	return r0, r1
}

// ListContainerInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListContainerInstancesWithContext(_a0 aws.Context, _a1 *ecs.ListContainerInstancesInput, _a2 ...request.Option) (*ecs.ListContainerInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListContainerInstancesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListContainerInstancesInput, ...request.Option) *ecs.ListContainerInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListContainerInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListContainerInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListServices provides a mock function with given fields: _a0
func (_m *ECSAPI) ListServices(_a0 *ecs.ListServicesInput) (*ecs.ListServicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListServicesOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListServicesInput) *ecs.ListServicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListServicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListServicesPages provides a mock function with given fields: _a0, _a1
func (_m *ECSAPI) ListServicesPages(_a0 *ecs.ListServicesInput, _a1 func(*ecs.ListServicesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.ListServicesInput, func(*ecs.ListServicesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListServicesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECSAPI) ListServicesPagesWithContext(_a0 aws.Context, _a1 *ecs.ListServicesInput, _a2 func(*ecs.ListServicesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListServicesInput, func(*ecs.ListServicesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListServicesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListServicesRequest(_a0 *ecs.ListServicesInput) (*request.Request, *ecs.ListServicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListServicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListServicesOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListServicesInput) *ecs.ListServicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListServicesOutput)
		}
	}

	return r0, r1
}

// ListServicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListServicesWithContext(_a0 aws.Context, _a1 *ecs.ListServicesInput, _a2 ...request.Option) (*ecs.ListServicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListServicesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListServicesInput, ...request.Option) *ecs.ListServicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListServicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTaskDefinitionFamilies provides a mock function with given fields: _a0
func (_m *ECSAPI) ListTaskDefinitionFamilies(_a0 *ecs.ListTaskDefinitionFamiliesInput) (*ecs.ListTaskDefinitionFamiliesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListTaskDefinitionFamiliesOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListTaskDefinitionFamiliesInput) *ecs.ListTaskDefinitionFamiliesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListTaskDefinitionFamiliesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListTaskDefinitionFamiliesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTaskDefinitionFamiliesPages provides a mock function with given fields: _a0, _a1
func (_m *ECSAPI) ListTaskDefinitionFamiliesPages(_a0 *ecs.ListTaskDefinitionFamiliesInput, _a1 func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.ListTaskDefinitionFamiliesInput, func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTaskDefinitionFamiliesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECSAPI) ListTaskDefinitionFamiliesPagesWithContext(_a0 aws.Context, _a1 *ecs.ListTaskDefinitionFamiliesInput, _a2 func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListTaskDefinitionFamiliesInput, func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTaskDefinitionFamiliesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListTaskDefinitionFamiliesRequest(_a0 *ecs.ListTaskDefinitionFamiliesInput) (*request.Request, *ecs.ListTaskDefinitionFamiliesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListTaskDefinitionFamiliesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListTaskDefinitionFamiliesOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListTaskDefinitionFamiliesInput) *ecs.ListTaskDefinitionFamiliesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListTaskDefinitionFamiliesOutput)
		}
	}

	return r0, r1
}

// ListTaskDefinitionFamiliesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListTaskDefinitionFamiliesWithContext(_a0 aws.Context, _a1 *ecs.ListTaskDefinitionFamiliesInput, _a2 ...request.Option) (*ecs.ListTaskDefinitionFamiliesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListTaskDefinitionFamiliesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListTaskDefinitionFamiliesInput, ...request.Option) *ecs.ListTaskDefinitionFamiliesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListTaskDefinitionFamiliesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListTaskDefinitionFamiliesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTaskDefinitions provides a mock function with given fields: _a0
func (_m *ECSAPI) ListTaskDefinitions(_a0 *ecs.ListTaskDefinitionsInput) (*ecs.ListTaskDefinitionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListTaskDefinitionsOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListTaskDefinitionsInput) *ecs.ListTaskDefinitionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListTaskDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListTaskDefinitionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTaskDefinitionsPages provides a mock function with given fields: _a0, _a1
func (_m *ECSAPI) ListTaskDefinitionsPages(_a0 *ecs.ListTaskDefinitionsInput, _a1 func(*ecs.ListTaskDefinitionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.ListTaskDefinitionsInput, func(*ecs.ListTaskDefinitionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTaskDefinitionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECSAPI) ListTaskDefinitionsPagesWithContext(_a0 aws.Context, _a1 *ecs.ListTaskDefinitionsInput, _a2 func(*ecs.ListTaskDefinitionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListTaskDefinitionsInput, func(*ecs.ListTaskDefinitionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTaskDefinitionsRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListTaskDefinitionsRequest(_a0 *ecs.ListTaskDefinitionsInput) (*request.Request, *ecs.ListTaskDefinitionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListTaskDefinitionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListTaskDefinitionsOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListTaskDefinitionsInput) *ecs.ListTaskDefinitionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListTaskDefinitionsOutput)
		}
	}

	return r0, r1
}

// ListTaskDefinitionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListTaskDefinitionsWithContext(_a0 aws.Context, _a1 *ecs.ListTaskDefinitionsInput, _a2 ...request.Option) (*ecs.ListTaskDefinitionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListTaskDefinitionsOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListTaskDefinitionsInput, ...request.Option) *ecs.ListTaskDefinitionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListTaskDefinitionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListTaskDefinitionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTasks provides a mock function with given fields: _a0
func (_m *ECSAPI) ListTasks(_a0 *ecs.ListTasksInput) (*ecs.ListTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.ListTasksOutput
	if rf, ok := ret.Get(0).(func(*ecs.ListTasksInput) *ecs.ListTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.ListTasksInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTasksPages provides a mock function with given fields: _a0, _a1
func (_m *ECSAPI) ListTasksPages(_a0 *ecs.ListTasksInput, _a1 func(*ecs.ListTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECSAPI) ListTasksPagesWithContext(_a0 aws.Context, _a1 *ecs.ListTasksInput, _a2 func(*ecs.ListTasksOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTasksRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) ListTasksRequest(_a0 *ecs.ListTasksInput) (*request.Request, *ecs.ListTasksOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.ListTasksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.ListTasksOutput
	if rf, ok := ret.Get(1).(func(*ecs.ListTasksInput) *ecs.ListTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.ListTasksOutput)
		}
	}

	return r0, r1
}

// ListTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) ListTasksWithContext(_a0 aws.Context, _a1 *ecs.ListTasksInput, _a2 ...request.Option) (*ecs.ListTasksOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.ListTasksOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.ListTasksInput, ...request.Option) *ecs.ListTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.ListTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.ListTasksInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutAttributes provides a mock function with given fields: _a0
func (_m *ECSAPI) PutAttributes(_a0 *ecs.PutAttributesInput) (*ecs.PutAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.PutAttributesOutput
	if rf, ok := ret.Get(0).(func(*ecs.PutAttributesInput) *ecs.PutAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.PutAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.PutAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutAttributesRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) PutAttributesRequest(_a0 *ecs.PutAttributesInput) (*request.Request, *ecs.PutAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.PutAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.PutAttributesOutput
	if rf, ok := ret.Get(1).(func(*ecs.PutAttributesInput) *ecs.PutAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.PutAttributesOutput)
		}
	}

	return r0, r1
}

// PutAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) PutAttributesWithContext(_a0 aws.Context, _a1 *ecs.PutAttributesInput, _a2 ...request.Option) (*ecs.PutAttributesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.PutAttributesOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.PutAttributesInput, ...request.Option) *ecs.PutAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.PutAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.PutAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterContainerInstance provides a mock function with given fields: _a0
func (_m *ECSAPI) RegisterContainerInstance(_a0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.RegisterContainerInstanceOutput
	if rf, ok := ret.Get(0).(func(*ecs.RegisterContainerInstanceInput) *ecs.RegisterContainerInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.RegisterContainerInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.RegisterContainerInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterContainerInstanceRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) RegisterContainerInstanceRequest(_a0 *ecs.RegisterContainerInstanceInput) (*request.Request, *ecs.RegisterContainerInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.RegisterContainerInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.RegisterContainerInstanceOutput
	if rf, ok := ret.Get(1).(func(*ecs.RegisterContainerInstanceInput) *ecs.RegisterContainerInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.RegisterContainerInstanceOutput)
		}
	}

	return r0, r1
}

// RegisterContainerInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) RegisterContainerInstanceWithContext(_a0 aws.Context, _a1 *ecs.RegisterContainerInstanceInput, _a2 ...request.Option) (*ecs.RegisterContainerInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.RegisterContainerInstanceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.RegisterContainerInstanceInput, ...request.Option) *ecs.RegisterContainerInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.RegisterContainerInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.RegisterContainerInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterTaskDefinition provides a mock function with given fields: _a0
func (_m *ECSAPI) RegisterTaskDefinition(_a0 *ecs.RegisterTaskDefinitionInput) (*ecs.RegisterTaskDefinitionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.RegisterTaskDefinitionOutput
	if rf, ok := ret.Get(0).(func(*ecs.RegisterTaskDefinitionInput) *ecs.RegisterTaskDefinitionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.RegisterTaskDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.RegisterTaskDefinitionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterTaskDefinitionRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) RegisterTaskDefinitionRequest(_a0 *ecs.RegisterTaskDefinitionInput) (*request.Request, *ecs.RegisterTaskDefinitionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.RegisterTaskDefinitionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.RegisterTaskDefinitionOutput
	if rf, ok := ret.Get(1).(func(*ecs.RegisterTaskDefinitionInput) *ecs.RegisterTaskDefinitionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.RegisterTaskDefinitionOutput)
		}
	}

	return r0, r1
}

// RegisterTaskDefinitionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) RegisterTaskDefinitionWithContext(_a0 aws.Context, _a1 *ecs.RegisterTaskDefinitionInput, _a2 ...request.Option) (*ecs.RegisterTaskDefinitionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.RegisterTaskDefinitionOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.RegisterTaskDefinitionInput, ...request.Option) *ecs.RegisterTaskDefinitionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.RegisterTaskDefinitionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.RegisterTaskDefinitionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RunTask provides a mock function with given fields: _a0
func (_m *ECSAPI) RunTask(_a0 *ecs.RunTaskInput) (*ecs.RunTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.RunTaskOutput
	if rf, ok := ret.Get(0).(func(*ecs.RunTaskInput) *ecs.RunTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.RunTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.RunTaskInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RunTaskRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) RunTaskRequest(_a0 *ecs.RunTaskInput) (*request.Request, *ecs.RunTaskOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.RunTaskInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.RunTaskOutput
	if rf, ok := ret.Get(1).(func(*ecs.RunTaskInput) *ecs.RunTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.RunTaskOutput)
		}
	}

	return r0, r1
}

// RunTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) RunTaskWithContext(_a0 aws.Context, _a1 *ecs.RunTaskInput, _a2 ...request.Option) (*ecs.RunTaskOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.RunTaskOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.RunTaskInput, ...request.Option) *ecs.RunTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.RunTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.RunTaskInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartTask provides a mock function with given fields: _a0
func (_m *ECSAPI) StartTask(_a0 *ecs.StartTaskInput) (*ecs.StartTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.StartTaskOutput
	if rf, ok := ret.Get(0).(func(*ecs.StartTaskInput) *ecs.StartTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.StartTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.StartTaskInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartTaskRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) StartTaskRequest(_a0 *ecs.StartTaskInput) (*request.Request, *ecs.StartTaskOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.StartTaskInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.StartTaskOutput
	if rf, ok := ret.Get(1).(func(*ecs.StartTaskInput) *ecs.StartTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.StartTaskOutput)
		}
	}

	return r0, r1
}

// StartTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) StartTaskWithContext(_a0 aws.Context, _a1 *ecs.StartTaskInput, _a2 ...request.Option) (*ecs.StartTaskOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.StartTaskOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.StartTaskInput, ...request.Option) *ecs.StartTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.StartTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.StartTaskInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopTask provides a mock function with given fields: _a0
func (_m *ECSAPI) StopTask(_a0 *ecs.StopTaskInput) (*ecs.StopTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.StopTaskOutput
	if rf, ok := ret.Get(0).(func(*ecs.StopTaskInput) *ecs.StopTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.StopTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.StopTaskInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopTaskRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) StopTaskRequest(_a0 *ecs.StopTaskInput) (*request.Request, *ecs.StopTaskOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.StopTaskInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.StopTaskOutput
	if rf, ok := ret.Get(1).(func(*ecs.StopTaskInput) *ecs.StopTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.StopTaskOutput)
		}
	}

	return r0, r1
}

// StopTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) StopTaskWithContext(_a0 aws.Context, _a1 *ecs.StopTaskInput, _a2 ...request.Option) (*ecs.StopTaskOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.StopTaskOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.StopTaskInput, ...request.Option) *ecs.StopTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.StopTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.StopTaskInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SubmitContainerStateChange provides a mock function with given fields: _a0
func (_m *ECSAPI) SubmitContainerStateChange(_a0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.SubmitContainerStateChangeOutput
	if rf, ok := ret.Get(0).(func(*ecs.SubmitContainerStateChangeInput) *ecs.SubmitContainerStateChangeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.SubmitContainerStateChangeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.SubmitContainerStateChangeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SubmitContainerStateChangeRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) SubmitContainerStateChangeRequest(_a0 *ecs.SubmitContainerStateChangeInput) (*request.Request, *ecs.SubmitContainerStateChangeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.SubmitContainerStateChangeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.SubmitContainerStateChangeOutput
	if rf, ok := ret.Get(1).(func(*ecs.SubmitContainerStateChangeInput) *ecs.SubmitContainerStateChangeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.SubmitContainerStateChangeOutput)
		}
	}

	return r0, r1
}

// SubmitContainerStateChangeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) SubmitContainerStateChangeWithContext(_a0 aws.Context, _a1 *ecs.SubmitContainerStateChangeInput, _a2 ...request.Option) (*ecs.SubmitContainerStateChangeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.SubmitContainerStateChangeOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.SubmitContainerStateChangeInput, ...request.Option) *ecs.SubmitContainerStateChangeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.SubmitContainerStateChangeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.SubmitContainerStateChangeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SubmitTaskStateChange provides a mock function with given fields: _a0
func (_m *ECSAPI) SubmitTaskStateChange(_a0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.SubmitTaskStateChangeOutput
	if rf, ok := ret.Get(0).(func(*ecs.SubmitTaskStateChangeInput) *ecs.SubmitTaskStateChangeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.SubmitTaskStateChangeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.SubmitTaskStateChangeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SubmitTaskStateChangeRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) SubmitTaskStateChangeRequest(_a0 *ecs.SubmitTaskStateChangeInput) (*request.Request, *ecs.SubmitTaskStateChangeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.SubmitTaskStateChangeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.SubmitTaskStateChangeOutput
	if rf, ok := ret.Get(1).(func(*ecs.SubmitTaskStateChangeInput) *ecs.SubmitTaskStateChangeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.SubmitTaskStateChangeOutput)
		}
	}

	return r0, r1
}

// SubmitTaskStateChangeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) SubmitTaskStateChangeWithContext(_a0 aws.Context, _a1 *ecs.SubmitTaskStateChangeInput, _a2 ...request.Option) (*ecs.SubmitTaskStateChangeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.SubmitTaskStateChangeOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.SubmitTaskStateChangeInput, ...request.Option) *ecs.SubmitTaskStateChangeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.SubmitTaskStateChangeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.SubmitTaskStateChangeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContainerAgent provides a mock function with given fields: _a0
func (_m *ECSAPI) UpdateContainerAgent(_a0 *ecs.UpdateContainerAgentInput) (*ecs.UpdateContainerAgentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.UpdateContainerAgentOutput
	if rf, ok := ret.Get(0).(func(*ecs.UpdateContainerAgentInput) *ecs.UpdateContainerAgentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.UpdateContainerAgentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.UpdateContainerAgentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContainerAgentRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) UpdateContainerAgentRequest(_a0 *ecs.UpdateContainerAgentInput) (*request.Request, *ecs.UpdateContainerAgentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.UpdateContainerAgentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.UpdateContainerAgentOutput
	if rf, ok := ret.Get(1).(func(*ecs.UpdateContainerAgentInput) *ecs.UpdateContainerAgentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.UpdateContainerAgentOutput)
		}
	}

	return r0, r1
}

// UpdateContainerAgentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) UpdateContainerAgentWithContext(_a0 aws.Context, _a1 *ecs.UpdateContainerAgentInput, _a2 ...request.Option) (*ecs.UpdateContainerAgentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.UpdateContainerAgentOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.UpdateContainerAgentInput, ...request.Option) *ecs.UpdateContainerAgentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.UpdateContainerAgentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.UpdateContainerAgentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContainerInstancesState provides a mock function with given fields: _a0
func (_m *ECSAPI) UpdateContainerInstancesState(_a0 *ecs.UpdateContainerInstancesStateInput) (*ecs.UpdateContainerInstancesStateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.UpdateContainerInstancesStateOutput
	if rf, ok := ret.Get(0).(func(*ecs.UpdateContainerInstancesStateInput) *ecs.UpdateContainerInstancesStateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.UpdateContainerInstancesStateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.UpdateContainerInstancesStateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContainerInstancesStateRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) UpdateContainerInstancesStateRequest(_a0 *ecs.UpdateContainerInstancesStateInput) (*request.Request, *ecs.UpdateContainerInstancesStateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.UpdateContainerInstancesStateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.UpdateContainerInstancesStateOutput
	if rf, ok := ret.Get(1).(func(*ecs.UpdateContainerInstancesStateInput) *ecs.UpdateContainerInstancesStateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.UpdateContainerInstancesStateOutput)
		}
	}

	return r0, r1
}

// UpdateContainerInstancesStateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) UpdateContainerInstancesStateWithContext(_a0 aws.Context, _a1 *ecs.UpdateContainerInstancesStateInput, _a2 ...request.Option) (*ecs.UpdateContainerInstancesStateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.UpdateContainerInstancesStateOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.UpdateContainerInstancesStateInput, ...request.Option) *ecs.UpdateContainerInstancesStateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.UpdateContainerInstancesStateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.UpdateContainerInstancesStateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateService provides a mock function with given fields: _a0
func (_m *ECSAPI) UpdateService(_a0 *ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecs.UpdateServiceOutput
	if rf, ok := ret.Get(0).(func(*ecs.UpdateServiceInput) *ecs.UpdateServiceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.UpdateServiceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecs.UpdateServiceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateServiceRequest provides a mock function with given fields: _a0
func (_m *ECSAPI) UpdateServiceRequest(_a0 *ecs.UpdateServiceInput) (*request.Request, *ecs.UpdateServiceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecs.UpdateServiceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecs.UpdateServiceOutput
	if rf, ok := ret.Get(1).(func(*ecs.UpdateServiceInput) *ecs.UpdateServiceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecs.UpdateServiceOutput)
		}
	}

	return r0, r1
}

// UpdateServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) UpdateServiceWithContext(_a0 aws.Context, _a1 *ecs.UpdateServiceInput, _a2 ...request.Option) (*ecs.UpdateServiceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecs.UpdateServiceOutput
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.UpdateServiceInput, ...request.Option) *ecs.UpdateServiceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecs.UpdateServiceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(aws.Context, *ecs.UpdateServiceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilServicesInactive provides a mock function with given fields: _a0
func (_m *ECSAPI) WaitUntilServicesInactive(_a0 *ecs.DescribeServicesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.DescribeServicesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilServicesInactiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) WaitUntilServicesInactiveWithContext(_a0 aws.Context, _a1 *ecs.DescribeServicesInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeServicesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilServicesStable provides a mock function with given fields: _a0
func (_m *ECSAPI) WaitUntilServicesStable(_a0 *ecs.DescribeServicesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.DescribeServicesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilServicesStableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) WaitUntilServicesStableWithContext(_a0 aws.Context, _a1 *ecs.DescribeServicesInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeServicesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTasksRunning provides a mock function with given fields: _a0
func (_m *ECSAPI) WaitUntilTasksRunning(_a0 *ecs.DescribeTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.DescribeTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTasksRunningWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) WaitUntilTasksRunningWithContext(_a0 aws.Context, _a1 *ecs.DescribeTasksInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTasksStopped provides a mock function with given fields: _a0
func (_m *ECSAPI) WaitUntilTasksStopped(_a0 *ecs.DescribeTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecs.DescribeTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTasksStoppedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECSAPI) WaitUntilTasksStoppedWithContext(_a0 aws.Context, _a1 *ecs.DescribeTasksInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(aws.Context, *ecs.DescribeTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
