Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

fakes

package

Go to main page

Versions in this module

v0

v0.0.9

Feb 16, 2024

v0.0.8

Nov 30, 2023

v0.0.7

Nov 1, 2023

v0.0.6

Oct 6, 2023

v0.0.5

Aug 11, 2023

v0.0.4

Aug 3, 2023

v0.0.3

Oct 28, 2022

v0.0.2

Jul 11, 2022

v0.0.1

Nov 18, 2021

Changes in this version

+ type FakeECSClient struct

+ CreateCapacityProviderRequestStub func(*ecs.CreateCapacityProviderInput) (*request.Request, *ecs.CreateCapacityProviderOutput)

+ CreateCapacityProviderStub func(*ecs.CreateCapacityProviderInput) (*ecs.CreateCapacityProviderOutput, error)

+ CreateCapacityProviderWithContextStub func(context.Context, *ecs.CreateCapacityProviderInput, ...request.Option) (*ecs.CreateCapacityProviderOutput, error)

+ CreateClusterRequestStub func(*ecs.CreateClusterInput) (*request.Request, *ecs.CreateClusterOutput)

+ CreateClusterStub func(*ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error)

+ CreateClusterWithContextStub func(context.Context, *ecs.CreateClusterInput, ...request.Option) (*ecs.CreateClusterOutput, error)

+ CreateServiceRequestStub func(*ecs.CreateServiceInput) (*request.Request, *ecs.CreateServiceOutput)

+ CreateServiceStub func(*ecs.CreateServiceInput) (*ecs.CreateServiceOutput, error)

+ CreateServiceWithContextStub func(context.Context, *ecs.CreateServiceInput, ...request.Option) (*ecs.CreateServiceOutput, error)

+ CreateTaskSetRequestStub func(*ecs.CreateTaskSetInput) (*request.Request, *ecs.CreateTaskSetOutput)

+ CreateTaskSetStub func(*ecs.CreateTaskSetInput) (*ecs.CreateTaskSetOutput, error)

+ CreateTaskSetWithContextStub func(context.Context, *ecs.CreateTaskSetInput, ...request.Option) (*ecs.CreateTaskSetOutput, error)

+ DeleteAccountSettingRequestStub func(*ecs.DeleteAccountSettingInput) (*request.Request, *ecs.DeleteAccountSettingOutput)

+ DeleteAccountSettingStub func(*ecs.DeleteAccountSettingInput) (*ecs.DeleteAccountSettingOutput, error)

+ DeleteAccountSettingWithContextStub func(context.Context, *ecs.DeleteAccountSettingInput, ...request.Option) (*ecs.DeleteAccountSettingOutput, error)

+ DeleteAttributesRequestStub func(*ecs.DeleteAttributesInput) (*request.Request, *ecs.DeleteAttributesOutput)

+ DeleteAttributesStub func(*ecs.DeleteAttributesInput) (*ecs.DeleteAttributesOutput, error)

+ DeleteAttributesWithContextStub func(context.Context, *ecs.DeleteAttributesInput, ...request.Option) (*ecs.DeleteAttributesOutput, error)

+ DeleteCapacityProviderRequestStub func(*ecs.DeleteCapacityProviderInput) (*request.Request, *ecs.DeleteCapacityProviderOutput)

+ DeleteCapacityProviderStub func(*ecs.DeleteCapacityProviderInput) (*ecs.DeleteCapacityProviderOutput, error)

+ DeleteCapacityProviderWithContextStub func(context.Context, *ecs.DeleteCapacityProviderInput, ...request.Option) (*ecs.DeleteCapacityProviderOutput, error)

+ DeleteClusterRequestStub func(*ecs.DeleteClusterInput) (*request.Request, *ecs.DeleteClusterOutput)

+ DeleteClusterStub func(*ecs.DeleteClusterInput) (*ecs.DeleteClusterOutput, error)

+ DeleteClusterWithContextStub func(context.Context, *ecs.DeleteClusterInput, ...request.Option) (*ecs.DeleteClusterOutput, error)

+ DeleteServiceRequestStub func(*ecs.DeleteServiceInput) (*request.Request, *ecs.DeleteServiceOutput)

+ DeleteServiceStub func(*ecs.DeleteServiceInput) (*ecs.DeleteServiceOutput, error)

+ DeleteServiceWithContextStub func(context.Context, *ecs.DeleteServiceInput, ...request.Option) (*ecs.DeleteServiceOutput, error)

+ DeleteTaskSetRequestStub func(*ecs.DeleteTaskSetInput) (*request.Request, *ecs.DeleteTaskSetOutput)

+ DeleteTaskSetStub func(*ecs.DeleteTaskSetInput) (*ecs.DeleteTaskSetOutput, error)

+ DeleteTaskSetWithContextStub func(context.Context, *ecs.DeleteTaskSetInput, ...request.Option) (*ecs.DeleteTaskSetOutput, error)

+ DeregisterContainerInstanceRequestStub func(*ecs.DeregisterContainerInstanceInput) (*request.Request, *ecs.DeregisterContainerInstanceOutput)

+ DeregisterContainerInstanceStub func(*ecs.DeregisterContainerInstanceInput) (*ecs.DeregisterContainerInstanceOutput, error)

+ DeregisterContainerInstanceWithContextStub func(context.Context, *ecs.DeregisterContainerInstanceInput, ...request.Option) (*ecs.DeregisterContainerInstanceOutput, error)

+ DeregisterTaskDefinitionRequestStub func(*ecs.DeregisterTaskDefinitionInput) (*request.Request, *ecs.DeregisterTaskDefinitionOutput)

+ DeregisterTaskDefinitionStub func(*ecs.DeregisterTaskDefinitionInput) (*ecs.DeregisterTaskDefinitionOutput, error)

+ DeregisterTaskDefinitionWithContextStub func(context.Context, *ecs.DeregisterTaskDefinitionInput, ...request.Option) (*ecs.DeregisterTaskDefinitionOutput, error)

+ DescribeCapacityProvidersRequestStub func(*ecs.DescribeCapacityProvidersInput) (*request.Request, *ecs.DescribeCapacityProvidersOutput)

+ DescribeCapacityProvidersStub func(*ecs.DescribeCapacityProvidersInput) (*ecs.DescribeCapacityProvidersOutput, error)

+ DescribeCapacityProvidersWithContextStub func(context.Context, *ecs.DescribeCapacityProvidersInput, ...request.Option) (*ecs.DescribeCapacityProvidersOutput, error)

+ DescribeClustersRequestStub func(*ecs.DescribeClustersInput) (*request.Request, *ecs.DescribeClustersOutput)

+ DescribeClustersStub func(*ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error)

+ DescribeClustersWithContextStub func(context.Context, *ecs.DescribeClustersInput, ...request.Option) (*ecs.DescribeClustersOutput, error)

+ DescribeContainerInstancesRequestStub func(*ecs.DescribeContainerInstancesInput) (*request.Request, *ecs.DescribeContainerInstancesOutput)

+ DescribeContainerInstancesStub func(*ecs.DescribeContainerInstancesInput) (*ecs.DescribeContainerInstancesOutput, error)

+ DescribeContainerInstancesWithContextStub func(context.Context, *ecs.DescribeContainerInstancesInput, ...request.Option) (*ecs.DescribeContainerInstancesOutput, error)

+ DescribeServicesRequestStub func(*ecs.DescribeServicesInput) (*request.Request, *ecs.DescribeServicesOutput)

+ DescribeServicesStub func(*ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error)

+ DescribeServicesWithContextStub func(context.Context, *ecs.DescribeServicesInput, ...request.Option) (*ecs.DescribeServicesOutput, error)

+ DescribeTaskDefinitionRequestStub func(*ecs.DescribeTaskDefinitionInput) (*request.Request, *ecs.DescribeTaskDefinitionOutput)

+ DescribeTaskDefinitionStub func(*ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error)

+ DescribeTaskDefinitionWithContextStub func(context.Context, *ecs.DescribeTaskDefinitionInput, ...request.Option) (*ecs.DescribeTaskDefinitionOutput, error)

+ DescribeTaskSetsRequestStub func(*ecs.DescribeTaskSetsInput) (*request.Request, *ecs.DescribeTaskSetsOutput)

+ DescribeTaskSetsStub func(*ecs.DescribeTaskSetsInput) (*ecs.DescribeTaskSetsOutput, error)

+ DescribeTaskSetsWithContextStub func(context.Context, *ecs.DescribeTaskSetsInput, ...request.Option) (*ecs.DescribeTaskSetsOutput, error)

+ DescribeTasksRequestStub func(*ecs.DescribeTasksInput) (*request.Request, *ecs.DescribeTasksOutput)

+ DescribeTasksStub func(*ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error)

+ DescribeTasksWithContextStub func(context.Context, *ecs.DescribeTasksInput, ...request.Option) (*ecs.DescribeTasksOutput, error)

+ DiscoverPollEndpointRequestStub func(*ecs.DiscoverPollEndpointInput) (*request.Request, *ecs.DiscoverPollEndpointOutput)

+ DiscoverPollEndpointStub func(*ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error)

+ DiscoverPollEndpointWithContextStub func(context.Context, *ecs.DiscoverPollEndpointInput, ...request.Option) (*ecs.DiscoverPollEndpointOutput, error)

+ ListAccountSettingsPagesStub func(*ecs.ListAccountSettingsInput, func(*ecs.ListAccountSettingsOutput, bool) bool) error

+ ListAccountSettingsPagesWithContextStub func(context.Context, *ecs.ListAccountSettingsInput, ...) error

+ ListAccountSettingsRequestStub func(*ecs.ListAccountSettingsInput) (*request.Request, *ecs.ListAccountSettingsOutput)

+ ListAccountSettingsStub func(*ecs.ListAccountSettingsInput) (*ecs.ListAccountSettingsOutput, error)

+ ListAccountSettingsWithContextStub func(context.Context, *ecs.ListAccountSettingsInput, ...request.Option) (*ecs.ListAccountSettingsOutput, error)

+ ListAttributesPagesStub func(*ecs.ListAttributesInput, func(*ecs.ListAttributesOutput, bool) bool) error

+ ListAttributesPagesWithContextStub func(context.Context, *ecs.ListAttributesInput, ...) error

+ ListAttributesRequestStub func(*ecs.ListAttributesInput) (*request.Request, *ecs.ListAttributesOutput)

+ ListAttributesStub func(*ecs.ListAttributesInput) (*ecs.ListAttributesOutput, error)

+ ListAttributesWithContextStub func(context.Context, *ecs.ListAttributesInput, ...request.Option) (*ecs.ListAttributesOutput, error)

+ ListClustersPagesStub func(*ecs.ListClustersInput, func(*ecs.ListClustersOutput, bool) bool) error

+ ListClustersPagesWithContextStub func(context.Context, *ecs.ListClustersInput, ...) error

+ ListClustersRequestStub func(*ecs.ListClustersInput) (*request.Request, *ecs.ListClustersOutput)

+ ListClustersStub func(*ecs.ListClustersInput) (*ecs.ListClustersOutput, error)

+ ListClustersWithContextStub func(context.Context, *ecs.ListClustersInput, ...request.Option) (*ecs.ListClustersOutput, error)

+ ListContainerInstancesPagesStub func(*ecs.ListContainerInstancesInput, ...) error

+ ListContainerInstancesPagesWithContextStub func(context.Context, *ecs.ListContainerInstancesInput, ...) error

+ ListContainerInstancesRequestStub func(*ecs.ListContainerInstancesInput) (*request.Request, *ecs.ListContainerInstancesOutput)

+ ListContainerInstancesStub func(*ecs.ListContainerInstancesInput) (*ecs.ListContainerInstancesOutput, error)

+ ListContainerInstancesWithContextStub func(context.Context, *ecs.ListContainerInstancesInput, ...request.Option) (*ecs.ListContainerInstancesOutput, error)

+ ListServicesPagesStub func(*ecs.ListServicesInput, func(*ecs.ListServicesOutput, bool) bool) error

+ ListServicesPagesWithContextStub func(context.Context, *ecs.ListServicesInput, ...) error

+ ListServicesRequestStub func(*ecs.ListServicesInput) (*request.Request, *ecs.ListServicesOutput)

+ ListServicesStub func(*ecs.ListServicesInput) (*ecs.ListServicesOutput, error)

+ ListServicesWithContextStub func(context.Context, *ecs.ListServicesInput, ...request.Option) (*ecs.ListServicesOutput, error)

+ ListTagsForResourceRequestStub func(*ecs.ListTagsForResourceInput) (*request.Request, *ecs.ListTagsForResourceOutput)

+ ListTagsForResourceStub func(*ecs.ListTagsForResourceInput) (*ecs.ListTagsForResourceOutput, error)

+ ListTagsForResourceWithContextStub func(context.Context, *ecs.ListTagsForResourceInput, ...request.Option) (*ecs.ListTagsForResourceOutput, error)

+ ListTaskDefinitionFamiliesPagesStub func(*ecs.ListTaskDefinitionFamiliesInput, ...) error

+ ListTaskDefinitionFamiliesPagesWithContextStub func(context.Context, *ecs.ListTaskDefinitionFamiliesInput, ...) error

+ ListTaskDefinitionFamiliesRequestStub func(*ecs.ListTaskDefinitionFamiliesInput) (*request.Request, *ecs.ListTaskDefinitionFamiliesOutput)

+ ListTaskDefinitionFamiliesStub func(*ecs.ListTaskDefinitionFamiliesInput) (*ecs.ListTaskDefinitionFamiliesOutput, error)

+ ListTaskDefinitionFamiliesWithContextStub func(context.Context, *ecs.ListTaskDefinitionFamiliesInput, ...request.Option) (*ecs.ListTaskDefinitionFamiliesOutput, error)

+ ListTaskDefinitionsPagesStub func(*ecs.ListTaskDefinitionsInput, func(*ecs.ListTaskDefinitionsOutput, bool) bool) error

+ ListTaskDefinitionsPagesWithContextStub func(context.Context, *ecs.ListTaskDefinitionsInput, ...) error

+ ListTaskDefinitionsRequestStub func(*ecs.ListTaskDefinitionsInput) (*request.Request, *ecs.ListTaskDefinitionsOutput)

+ ListTaskDefinitionsStub func(*ecs.ListTaskDefinitionsInput) (*ecs.ListTaskDefinitionsOutput, error)

+ ListTaskDefinitionsWithContextStub func(context.Context, *ecs.ListTaskDefinitionsInput, ...request.Option) (*ecs.ListTaskDefinitionsOutput, error)

+ ListTasksPagesStub func(*ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool) error

+ ListTasksPagesWithContextStub func(context.Context, *ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool, ...) error

+ ListTasksRequestStub func(*ecs.ListTasksInput) (*request.Request, *ecs.ListTasksOutput)

+ ListTasksStub func(*ecs.ListTasksInput) (*ecs.ListTasksOutput, error)

+ ListTasksWithContextStub func(context.Context, *ecs.ListTasksInput, ...request.Option) (*ecs.ListTasksOutput, error)

+ PutAccountSettingDefaultRequestStub func(*ecs.PutAccountSettingDefaultInput) (*request.Request, *ecs.PutAccountSettingDefaultOutput)

+ PutAccountSettingDefaultStub func(*ecs.PutAccountSettingDefaultInput) (*ecs.PutAccountSettingDefaultOutput, error)

+ PutAccountSettingDefaultWithContextStub func(context.Context, *ecs.PutAccountSettingDefaultInput, ...request.Option) (*ecs.PutAccountSettingDefaultOutput, error)

+ PutAccountSettingRequestStub func(*ecs.PutAccountSettingInput) (*request.Request, *ecs.PutAccountSettingOutput)

+ PutAccountSettingStub func(*ecs.PutAccountSettingInput) (*ecs.PutAccountSettingOutput, error)

+ PutAccountSettingWithContextStub func(context.Context, *ecs.PutAccountSettingInput, ...request.Option) (*ecs.PutAccountSettingOutput, error)

+ PutAttributesRequestStub func(*ecs.PutAttributesInput) (*request.Request, *ecs.PutAttributesOutput)

+ PutAttributesStub func(*ecs.PutAttributesInput) (*ecs.PutAttributesOutput, error)

+ PutAttributesWithContextStub func(context.Context, *ecs.PutAttributesInput, ...request.Option) (*ecs.PutAttributesOutput, error)

+ PutClusterCapacityProvidersRequestStub func(*ecs.PutClusterCapacityProvidersInput) (*request.Request, *ecs.PutClusterCapacityProvidersOutput)

+ PutClusterCapacityProvidersStub func(*ecs.PutClusterCapacityProvidersInput) (*ecs.PutClusterCapacityProvidersOutput, error)

+ PutClusterCapacityProvidersWithContextStub func(context.Context, *ecs.PutClusterCapacityProvidersInput, ...request.Option) (*ecs.PutClusterCapacityProvidersOutput, error)

+ RegisterContainerInstanceRequestStub func(*ecs.RegisterContainerInstanceInput) (*request.Request, *ecs.RegisterContainerInstanceOutput)

+ RegisterContainerInstanceStub func(*ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error)

+ RegisterContainerInstanceWithContextStub func(context.Context, *ecs.RegisterContainerInstanceInput, ...request.Option) (*ecs.RegisterContainerInstanceOutput, error)

+ RegisterTaskDefinitionRequestStub func(*ecs.RegisterTaskDefinitionInput) (*request.Request, *ecs.RegisterTaskDefinitionOutput)

+ RegisterTaskDefinitionStub func(*ecs.RegisterTaskDefinitionInput) (*ecs.RegisterTaskDefinitionOutput, error)

+ RegisterTaskDefinitionWithContextStub func(context.Context, *ecs.RegisterTaskDefinitionInput, ...request.Option) (*ecs.RegisterTaskDefinitionOutput, error)

+ RunTaskRequestStub func(*ecs.RunTaskInput) (*request.Request, *ecs.RunTaskOutput)

+ RunTaskStub func(*ecs.RunTaskInput) (*ecs.RunTaskOutput, error)

+ RunTaskWithContextStub func(context.Context, *ecs.RunTaskInput, ...request.Option) (*ecs.RunTaskOutput, error)

+ StartTaskRequestStub func(*ecs.StartTaskInput) (*request.Request, *ecs.StartTaskOutput)

+ StartTaskStub func(*ecs.StartTaskInput) (*ecs.StartTaskOutput, error)

+ StartTaskWithContextStub func(context.Context, *ecs.StartTaskInput, ...request.Option) (*ecs.StartTaskOutput, error)

+ StopTaskRequestStub func(*ecs.StopTaskInput) (*request.Request, *ecs.StopTaskOutput)

+ StopTaskStub func(*ecs.StopTaskInput) (*ecs.StopTaskOutput, error)

+ StopTaskWithContextStub func(context.Context, *ecs.StopTaskInput, ...request.Option) (*ecs.StopTaskOutput, error)

+ SubmitAttachmentStateChangesRequestStub func(*ecs.SubmitAttachmentStateChangesInput) (*request.Request, *ecs.SubmitAttachmentStateChangesOutput)

+ SubmitAttachmentStateChangesStub func(*ecs.SubmitAttachmentStateChangesInput) (*ecs.SubmitAttachmentStateChangesOutput, error)

+ SubmitAttachmentStateChangesWithContextStub func(context.Context, *ecs.SubmitAttachmentStateChangesInput, ...request.Option) (*ecs.SubmitAttachmentStateChangesOutput, error)

+ SubmitContainerStateChangeRequestStub func(*ecs.SubmitContainerStateChangeInput) (*request.Request, *ecs.SubmitContainerStateChangeOutput)

+ SubmitContainerStateChangeStub func(*ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error)

+ SubmitContainerStateChangeWithContextStub func(context.Context, *ecs.SubmitContainerStateChangeInput, ...request.Option) (*ecs.SubmitContainerStateChangeOutput, error)

+ SubmitTaskStateChangeRequestStub func(*ecs.SubmitTaskStateChangeInput) (*request.Request, *ecs.SubmitTaskStateChangeOutput)

+ SubmitTaskStateChangeStub func(*ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error)

+ SubmitTaskStateChangeWithContextStub func(context.Context, *ecs.SubmitTaskStateChangeInput, ...request.Option) (*ecs.SubmitTaskStateChangeOutput, error)

+ TagResourceRequestStub func(*ecs.TagResourceInput) (*request.Request, *ecs.TagResourceOutput)

+ TagResourceStub func(*ecs.TagResourceInput) (*ecs.TagResourceOutput, error)

+ TagResourceWithContextStub func(context.Context, *ecs.TagResourceInput, ...request.Option) (*ecs.TagResourceOutput, error)

+ UntagResourceRequestStub func(*ecs.UntagResourceInput) (*request.Request, *ecs.UntagResourceOutput)

+ UntagResourceStub func(*ecs.UntagResourceInput) (*ecs.UntagResourceOutput, error)

+ UntagResourceWithContextStub func(context.Context, *ecs.UntagResourceInput, ...request.Option) (*ecs.UntagResourceOutput, error)

+ UpdateCapacityProviderRequestStub func(*ecs.UpdateCapacityProviderInput) (*request.Request, *ecs.UpdateCapacityProviderOutput)

+ UpdateCapacityProviderStub func(*ecs.UpdateCapacityProviderInput) (*ecs.UpdateCapacityProviderOutput, error)

+ UpdateCapacityProviderWithContextStub func(context.Context, *ecs.UpdateCapacityProviderInput, ...request.Option) (*ecs.UpdateCapacityProviderOutput, error)

+ UpdateClusterSettingsRequestStub func(*ecs.UpdateClusterSettingsInput) (*request.Request, *ecs.UpdateClusterSettingsOutput)

+ UpdateClusterSettingsStub func(*ecs.UpdateClusterSettingsInput) (*ecs.UpdateClusterSettingsOutput, error)

+ UpdateClusterSettingsWithContextStub func(context.Context, *ecs.UpdateClusterSettingsInput, ...request.Option) (*ecs.UpdateClusterSettingsOutput, error)

+ UpdateContainerAgentRequestStub func(*ecs.UpdateContainerAgentInput) (*request.Request, *ecs.UpdateContainerAgentOutput)

+ UpdateContainerAgentStub func(*ecs.UpdateContainerAgentInput) (*ecs.UpdateContainerAgentOutput, error)

+ UpdateContainerAgentWithContextStub func(context.Context, *ecs.UpdateContainerAgentInput, ...request.Option) (*ecs.UpdateContainerAgentOutput, error)

+ UpdateContainerInstancesStateRequestStub func(*ecs.UpdateContainerInstancesStateInput) (*request.Request, *ecs.UpdateContainerInstancesStateOutput)

+ UpdateContainerInstancesStateStub func(*ecs.UpdateContainerInstancesStateInput) (*ecs.UpdateContainerInstancesStateOutput, error)

+ UpdateContainerInstancesStateWithContextStub func(context.Context, *ecs.UpdateContainerInstancesStateInput, ...request.Option) (*ecs.UpdateContainerInstancesStateOutput, error)

+ UpdateServicePrimaryTaskSetRequestStub func(*ecs.UpdateServicePrimaryTaskSetInput) (*request.Request, *ecs.UpdateServicePrimaryTaskSetOutput)

+ UpdateServicePrimaryTaskSetStub func(*ecs.UpdateServicePrimaryTaskSetInput) (*ecs.UpdateServicePrimaryTaskSetOutput, error)

+ UpdateServicePrimaryTaskSetWithContextStub func(context.Context, *ecs.UpdateServicePrimaryTaskSetInput, ...request.Option) (*ecs.UpdateServicePrimaryTaskSetOutput, error)

+ UpdateServiceRequestStub func(*ecs.UpdateServiceInput) (*request.Request, *ecs.UpdateServiceOutput)

+ UpdateServiceStub func(*ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error)

+ UpdateServiceWithContextStub func(context.Context, *ecs.UpdateServiceInput, ...request.Option) (*ecs.UpdateServiceOutput, error)

+ UpdateTaskSetRequestStub func(*ecs.UpdateTaskSetInput) (*request.Request, *ecs.UpdateTaskSetOutput)

+ UpdateTaskSetStub func(*ecs.UpdateTaskSetInput) (*ecs.UpdateTaskSetOutput, error)

+ UpdateTaskSetWithContextStub func(context.Context, *ecs.UpdateTaskSetInput, ...request.Option) (*ecs.UpdateTaskSetOutput, error)

+ WaitUntilServicesInactiveStub func(*ecs.DescribeServicesInput) error

+ WaitUntilServicesInactiveWithContextStub func(context.Context, *ecs.DescribeServicesInput, ...request.WaiterOption) error

+ WaitUntilServicesStableStub func(*ecs.DescribeServicesInput) error

+ WaitUntilServicesStableWithContextStub func(context.Context, *ecs.DescribeServicesInput, ...request.WaiterOption) error

+ WaitUntilTasksRunningStub func(*ecs.DescribeTasksInput) error

+ WaitUntilTasksRunningWithContextStub func(context.Context, *ecs.DescribeTasksInput, ...request.WaiterOption) error

+ WaitUntilTasksStoppedStub func(*ecs.DescribeTasksInput) error

+ WaitUntilTasksStoppedWithContextStub func(context.Context, *ecs.DescribeTasksInput, ...request.WaiterOption) error

+ func (fake *FakeECSClient) CreateCapacityProvider(arg1 *ecs.CreateCapacityProviderInput) (*ecs.CreateCapacityProviderOutput, error)

+ func (fake *FakeECSClient) CreateCapacityProviderArgsForCall(i int) *ecs.CreateCapacityProviderInput

+ func (fake *FakeECSClient) CreateCapacityProviderCallCount() int

+ func (fake *FakeECSClient) CreateCapacityProviderCalls(...)

+ func (fake *FakeECSClient) CreateCapacityProviderRequest(arg1 *ecs.CreateCapacityProviderInput) (*request.Request, *ecs.CreateCapacityProviderOutput)

+ func (fake *FakeECSClient) CreateCapacityProviderRequestArgsForCall(i int) *ecs.CreateCapacityProviderInput

+ func (fake *FakeECSClient) CreateCapacityProviderRequestCallCount() int

+ func (fake *FakeECSClient) CreateCapacityProviderRequestCalls(...)

+ func (fake *FakeECSClient) CreateCapacityProviderRequestReturns(result1 *request.Request, result2 *ecs.CreateCapacityProviderOutput)

+ func (fake *FakeECSClient) CreateCapacityProviderRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.CreateCapacityProviderOutput)

+ func (fake *FakeECSClient) CreateCapacityProviderReturns(result1 *ecs.CreateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) CreateCapacityProviderReturnsOnCall(i int, result1 *ecs.CreateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) CreateCapacityProviderWithContext(arg1 context.Context, arg2 *ecs.CreateCapacityProviderInput, ...) (*ecs.CreateCapacityProviderOutput, error)

+ func (fake *FakeECSClient) CreateCapacityProviderWithContextArgsForCall(i int) (context.Context, *ecs.CreateCapacityProviderInput, []request.Option)

+ func (fake *FakeECSClient) CreateCapacityProviderWithContextCallCount() int

+ func (fake *FakeECSClient) CreateCapacityProviderWithContextCalls(...)

+ func (fake *FakeECSClient) CreateCapacityProviderWithContextReturns(result1 *ecs.CreateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) CreateCapacityProviderWithContextReturnsOnCall(i int, result1 *ecs.CreateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) CreateCluster(arg1 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error)

+ func (fake *FakeECSClient) CreateClusterArgsForCall(i int) *ecs.CreateClusterInput

+ func (fake *FakeECSClient) CreateClusterCallCount() int

+ func (fake *FakeECSClient) CreateClusterCalls(stub func(*ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error))

+ func (fake *FakeECSClient) CreateClusterRequest(arg1 *ecs.CreateClusterInput) (*request.Request, *ecs.CreateClusterOutput)

+ func (fake *FakeECSClient) CreateClusterRequestArgsForCall(i int) *ecs.CreateClusterInput

+ func (fake *FakeECSClient) CreateClusterRequestCallCount() int

+ func (fake *FakeECSClient) CreateClusterRequestCalls(...)

+ func (fake *FakeECSClient) CreateClusterRequestReturns(result1 *request.Request, result2 *ecs.CreateClusterOutput)

+ func (fake *FakeECSClient) CreateClusterRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.CreateClusterOutput)

+ func (fake *FakeECSClient) CreateClusterReturns(result1 *ecs.CreateClusterOutput, result2 error)

+ func (fake *FakeECSClient) CreateClusterReturnsOnCall(i int, result1 *ecs.CreateClusterOutput, result2 error)

+ func (fake *FakeECSClient) CreateClusterWithContext(arg1 context.Context, arg2 *ecs.CreateClusterInput, arg3 ...request.Option) (*ecs.CreateClusterOutput, error)

+ func (fake *FakeECSClient) CreateClusterWithContextArgsForCall(i int) (context.Context, *ecs.CreateClusterInput, []request.Option)

+ func (fake *FakeECSClient) CreateClusterWithContextCallCount() int

+ func (fake *FakeECSClient) CreateClusterWithContextCalls(...)

+ func (fake *FakeECSClient) CreateClusterWithContextReturns(result1 *ecs.CreateClusterOutput, result2 error)

+ func (fake *FakeECSClient) CreateClusterWithContextReturnsOnCall(i int, result1 *ecs.CreateClusterOutput, result2 error)

+ func (fake *FakeECSClient) CreateService(arg1 *ecs.CreateServiceInput) (*ecs.CreateServiceOutput, error)

+ func (fake *FakeECSClient) CreateServiceArgsForCall(i int) *ecs.CreateServiceInput

+ func (fake *FakeECSClient) CreateServiceCallCount() int

+ func (fake *FakeECSClient) CreateServiceCalls(stub func(*ecs.CreateServiceInput) (*ecs.CreateServiceOutput, error))

+ func (fake *FakeECSClient) CreateServiceRequest(arg1 *ecs.CreateServiceInput) (*request.Request, *ecs.CreateServiceOutput)

+ func (fake *FakeECSClient) CreateServiceRequestArgsForCall(i int) *ecs.CreateServiceInput

+ func (fake *FakeECSClient) CreateServiceRequestCallCount() int

+ func (fake *FakeECSClient) CreateServiceRequestCalls(...)

+ func (fake *FakeECSClient) CreateServiceRequestReturns(result1 *request.Request, result2 *ecs.CreateServiceOutput)

+ func (fake *FakeECSClient) CreateServiceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.CreateServiceOutput)

+ func (fake *FakeECSClient) CreateServiceReturns(result1 *ecs.CreateServiceOutput, result2 error)

+ func (fake *FakeECSClient) CreateServiceReturnsOnCall(i int, result1 *ecs.CreateServiceOutput, result2 error)

+ func (fake *FakeECSClient) CreateServiceWithContext(arg1 context.Context, arg2 *ecs.CreateServiceInput, arg3 ...request.Option) (*ecs.CreateServiceOutput, error)

+ func (fake *FakeECSClient) CreateServiceWithContextArgsForCall(i int) (context.Context, *ecs.CreateServiceInput, []request.Option)

+ func (fake *FakeECSClient) CreateServiceWithContextCallCount() int

+ func (fake *FakeECSClient) CreateServiceWithContextCalls(...)

+ func (fake *FakeECSClient) CreateServiceWithContextReturns(result1 *ecs.CreateServiceOutput, result2 error)

+ func (fake *FakeECSClient) CreateServiceWithContextReturnsOnCall(i int, result1 *ecs.CreateServiceOutput, result2 error)

+ func (fake *FakeECSClient) CreateTaskSet(arg1 *ecs.CreateTaskSetInput) (*ecs.CreateTaskSetOutput, error)

+ func (fake *FakeECSClient) CreateTaskSetArgsForCall(i int) *ecs.CreateTaskSetInput

+ func (fake *FakeECSClient) CreateTaskSetCallCount() int

+ func (fake *FakeECSClient) CreateTaskSetCalls(stub func(*ecs.CreateTaskSetInput) (*ecs.CreateTaskSetOutput, error))

+ func (fake *FakeECSClient) CreateTaskSetRequest(arg1 *ecs.CreateTaskSetInput) (*request.Request, *ecs.CreateTaskSetOutput)

+ func (fake *FakeECSClient) CreateTaskSetRequestArgsForCall(i int) *ecs.CreateTaskSetInput

+ func (fake *FakeECSClient) CreateTaskSetRequestCallCount() int

+ func (fake *FakeECSClient) CreateTaskSetRequestCalls(...)

+ func (fake *FakeECSClient) CreateTaskSetRequestReturns(result1 *request.Request, result2 *ecs.CreateTaskSetOutput)

+ func (fake *FakeECSClient) CreateTaskSetRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.CreateTaskSetOutput)

+ func (fake *FakeECSClient) CreateTaskSetReturns(result1 *ecs.CreateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) CreateTaskSetReturnsOnCall(i int, result1 *ecs.CreateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) CreateTaskSetWithContext(arg1 context.Context, arg2 *ecs.CreateTaskSetInput, arg3 ...request.Option) (*ecs.CreateTaskSetOutput, error)

+ func (fake *FakeECSClient) CreateTaskSetWithContextArgsForCall(i int) (context.Context, *ecs.CreateTaskSetInput, []request.Option)

+ func (fake *FakeECSClient) CreateTaskSetWithContextCallCount() int

+ func (fake *FakeECSClient) CreateTaskSetWithContextCalls(...)

+ func (fake *FakeECSClient) CreateTaskSetWithContextReturns(result1 *ecs.CreateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) CreateTaskSetWithContextReturnsOnCall(i int, result1 *ecs.CreateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAccountSetting(arg1 *ecs.DeleteAccountSettingInput) (*ecs.DeleteAccountSettingOutput, error)

+ func (fake *FakeECSClient) DeleteAccountSettingArgsForCall(i int) *ecs.DeleteAccountSettingInput

+ func (fake *FakeECSClient) DeleteAccountSettingCallCount() int

+ func (fake *FakeECSClient) DeleteAccountSettingCalls(...)

+ func (fake *FakeECSClient) DeleteAccountSettingRequest(arg1 *ecs.DeleteAccountSettingInput) (*request.Request, *ecs.DeleteAccountSettingOutput)

+ func (fake *FakeECSClient) DeleteAccountSettingRequestArgsForCall(i int) *ecs.DeleteAccountSettingInput

+ func (fake *FakeECSClient) DeleteAccountSettingRequestCallCount() int

+ func (fake *FakeECSClient) DeleteAccountSettingRequestCalls(...)

+ func (fake *FakeECSClient) DeleteAccountSettingRequestReturns(result1 *request.Request, result2 *ecs.DeleteAccountSettingOutput)

+ func (fake *FakeECSClient) DeleteAccountSettingRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeleteAccountSettingOutput)

+ func (fake *FakeECSClient) DeleteAccountSettingReturns(result1 *ecs.DeleteAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAccountSettingReturnsOnCall(i int, result1 *ecs.DeleteAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAccountSettingWithContext(arg1 context.Context, arg2 *ecs.DeleteAccountSettingInput, ...) (*ecs.DeleteAccountSettingOutput, error)

+ func (fake *FakeECSClient) DeleteAccountSettingWithContextArgsForCall(i int) (context.Context, *ecs.DeleteAccountSettingInput, []request.Option)

+ func (fake *FakeECSClient) DeleteAccountSettingWithContextCallCount() int

+ func (fake *FakeECSClient) DeleteAccountSettingWithContextCalls(...)

+ func (fake *FakeECSClient) DeleteAccountSettingWithContextReturns(result1 *ecs.DeleteAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAccountSettingWithContextReturnsOnCall(i int, result1 *ecs.DeleteAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAttributes(arg1 *ecs.DeleteAttributesInput) (*ecs.DeleteAttributesOutput, error)

+ func (fake *FakeECSClient) DeleteAttributesArgsForCall(i int) *ecs.DeleteAttributesInput

+ func (fake *FakeECSClient) DeleteAttributesCallCount() int

+ func (fake *FakeECSClient) DeleteAttributesCalls(stub func(*ecs.DeleteAttributesInput) (*ecs.DeleteAttributesOutput, error))

+ func (fake *FakeECSClient) DeleteAttributesRequest(arg1 *ecs.DeleteAttributesInput) (*request.Request, *ecs.DeleteAttributesOutput)

+ func (fake *FakeECSClient) DeleteAttributesRequestArgsForCall(i int) *ecs.DeleteAttributesInput

+ func (fake *FakeECSClient) DeleteAttributesRequestCallCount() int

+ func (fake *FakeECSClient) DeleteAttributesRequestCalls(...)

+ func (fake *FakeECSClient) DeleteAttributesRequestReturns(result1 *request.Request, result2 *ecs.DeleteAttributesOutput)

+ func (fake *FakeECSClient) DeleteAttributesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeleteAttributesOutput)

+ func (fake *FakeECSClient) DeleteAttributesReturns(result1 *ecs.DeleteAttributesOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAttributesReturnsOnCall(i int, result1 *ecs.DeleteAttributesOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAttributesWithContext(arg1 context.Context, arg2 *ecs.DeleteAttributesInput, arg3 ...request.Option) (*ecs.DeleteAttributesOutput, error)

+ func (fake *FakeECSClient) DeleteAttributesWithContextArgsForCall(i int) (context.Context, *ecs.DeleteAttributesInput, []request.Option)

+ func (fake *FakeECSClient) DeleteAttributesWithContextCallCount() int

+ func (fake *FakeECSClient) DeleteAttributesWithContextCalls(...)

+ func (fake *FakeECSClient) DeleteAttributesWithContextReturns(result1 *ecs.DeleteAttributesOutput, result2 error)

+ func (fake *FakeECSClient) DeleteAttributesWithContextReturnsOnCall(i int, result1 *ecs.DeleteAttributesOutput, result2 error)

+ func (fake *FakeECSClient) DeleteCapacityProvider(arg1 *ecs.DeleteCapacityProviderInput) (*ecs.DeleteCapacityProviderOutput, error)

+ func (fake *FakeECSClient) DeleteCapacityProviderArgsForCall(i int) *ecs.DeleteCapacityProviderInput

+ func (fake *FakeECSClient) DeleteCapacityProviderCallCount() int

+ func (fake *FakeECSClient) DeleteCapacityProviderCalls(...)

+ func (fake *FakeECSClient) DeleteCapacityProviderRequest(arg1 *ecs.DeleteCapacityProviderInput) (*request.Request, *ecs.DeleteCapacityProviderOutput)

+ func (fake *FakeECSClient) DeleteCapacityProviderRequestArgsForCall(i int) *ecs.DeleteCapacityProviderInput

+ func (fake *FakeECSClient) DeleteCapacityProviderRequestCallCount() int

+ func (fake *FakeECSClient) DeleteCapacityProviderRequestCalls(...)

+ func (fake *FakeECSClient) DeleteCapacityProviderRequestReturns(result1 *request.Request, result2 *ecs.DeleteCapacityProviderOutput)

+ func (fake *FakeECSClient) DeleteCapacityProviderRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeleteCapacityProviderOutput)

+ func (fake *FakeECSClient) DeleteCapacityProviderReturns(result1 *ecs.DeleteCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) DeleteCapacityProviderReturnsOnCall(i int, result1 *ecs.DeleteCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) DeleteCapacityProviderWithContext(arg1 context.Context, arg2 *ecs.DeleteCapacityProviderInput, ...) (*ecs.DeleteCapacityProviderOutput, error)

+ func (fake *FakeECSClient) DeleteCapacityProviderWithContextArgsForCall(i int) (context.Context, *ecs.DeleteCapacityProviderInput, []request.Option)

+ func (fake *FakeECSClient) DeleteCapacityProviderWithContextCallCount() int

+ func (fake *FakeECSClient) DeleteCapacityProviderWithContextCalls(...)

+ func (fake *FakeECSClient) DeleteCapacityProviderWithContextReturns(result1 *ecs.DeleteCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) DeleteCapacityProviderWithContextReturnsOnCall(i int, result1 *ecs.DeleteCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) DeleteCluster(arg1 *ecs.DeleteClusterInput) (*ecs.DeleteClusterOutput, error)

+ func (fake *FakeECSClient) DeleteClusterArgsForCall(i int) *ecs.DeleteClusterInput

+ func (fake *FakeECSClient) DeleteClusterCallCount() int

+ func (fake *FakeECSClient) DeleteClusterCalls(stub func(*ecs.DeleteClusterInput) (*ecs.DeleteClusterOutput, error))

+ func (fake *FakeECSClient) DeleteClusterRequest(arg1 *ecs.DeleteClusterInput) (*request.Request, *ecs.DeleteClusterOutput)

+ func (fake *FakeECSClient) DeleteClusterRequestArgsForCall(i int) *ecs.DeleteClusterInput

+ func (fake *FakeECSClient) DeleteClusterRequestCallCount() int

+ func (fake *FakeECSClient) DeleteClusterRequestCalls(...)

+ func (fake *FakeECSClient) DeleteClusterRequestReturns(result1 *request.Request, result2 *ecs.DeleteClusterOutput)

+ func (fake *FakeECSClient) DeleteClusterRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeleteClusterOutput)

+ func (fake *FakeECSClient) DeleteClusterReturns(result1 *ecs.DeleteClusterOutput, result2 error)

+ func (fake *FakeECSClient) DeleteClusterReturnsOnCall(i int, result1 *ecs.DeleteClusterOutput, result2 error)

+ func (fake *FakeECSClient) DeleteClusterWithContext(arg1 context.Context, arg2 *ecs.DeleteClusterInput, arg3 ...request.Option) (*ecs.DeleteClusterOutput, error)

+ func (fake *FakeECSClient) DeleteClusterWithContextArgsForCall(i int) (context.Context, *ecs.DeleteClusterInput, []request.Option)

+ func (fake *FakeECSClient) DeleteClusterWithContextCallCount() int

+ func (fake *FakeECSClient) DeleteClusterWithContextCalls(...)

+ func (fake *FakeECSClient) DeleteClusterWithContextReturns(result1 *ecs.DeleteClusterOutput, result2 error)

+ func (fake *FakeECSClient) DeleteClusterWithContextReturnsOnCall(i int, result1 *ecs.DeleteClusterOutput, result2 error)

+ func (fake *FakeECSClient) DeleteService(arg1 *ecs.DeleteServiceInput) (*ecs.DeleteServiceOutput, error)

+ func (fake *FakeECSClient) DeleteServiceArgsForCall(i int) *ecs.DeleteServiceInput

+ func (fake *FakeECSClient) DeleteServiceCallCount() int

+ func (fake *FakeECSClient) DeleteServiceCalls(stub func(*ecs.DeleteServiceInput) (*ecs.DeleteServiceOutput, error))

+ func (fake *FakeECSClient) DeleteServiceRequest(arg1 *ecs.DeleteServiceInput) (*request.Request, *ecs.DeleteServiceOutput)

+ func (fake *FakeECSClient) DeleteServiceRequestArgsForCall(i int) *ecs.DeleteServiceInput

+ func (fake *FakeECSClient) DeleteServiceRequestCallCount() int

+ func (fake *FakeECSClient) DeleteServiceRequestCalls(...)

+ func (fake *FakeECSClient) DeleteServiceRequestReturns(result1 *request.Request, result2 *ecs.DeleteServiceOutput)

+ func (fake *FakeECSClient) DeleteServiceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeleteServiceOutput)

+ func (fake *FakeECSClient) DeleteServiceReturns(result1 *ecs.DeleteServiceOutput, result2 error)

+ func (fake *FakeECSClient) DeleteServiceReturnsOnCall(i int, result1 *ecs.DeleteServiceOutput, result2 error)

+ func (fake *FakeECSClient) DeleteServiceWithContext(arg1 context.Context, arg2 *ecs.DeleteServiceInput, arg3 ...request.Option) (*ecs.DeleteServiceOutput, error)

+ func (fake *FakeECSClient) DeleteServiceWithContextArgsForCall(i int) (context.Context, *ecs.DeleteServiceInput, []request.Option)

+ func (fake *FakeECSClient) DeleteServiceWithContextCallCount() int

+ func (fake *FakeECSClient) DeleteServiceWithContextCalls(...)

+ func (fake *FakeECSClient) DeleteServiceWithContextReturns(result1 *ecs.DeleteServiceOutput, result2 error)

+ func (fake *FakeECSClient) DeleteServiceWithContextReturnsOnCall(i int, result1 *ecs.DeleteServiceOutput, result2 error)

+ func (fake *FakeECSClient) DeleteTaskSet(arg1 *ecs.DeleteTaskSetInput) (*ecs.DeleteTaskSetOutput, error)

+ func (fake *FakeECSClient) DeleteTaskSetArgsForCall(i int) *ecs.DeleteTaskSetInput

+ func (fake *FakeECSClient) DeleteTaskSetCallCount() int

+ func (fake *FakeECSClient) DeleteTaskSetCalls(stub func(*ecs.DeleteTaskSetInput) (*ecs.DeleteTaskSetOutput, error))

+ func (fake *FakeECSClient) DeleteTaskSetRequest(arg1 *ecs.DeleteTaskSetInput) (*request.Request, *ecs.DeleteTaskSetOutput)

+ func (fake *FakeECSClient) DeleteTaskSetRequestArgsForCall(i int) *ecs.DeleteTaskSetInput

+ func (fake *FakeECSClient) DeleteTaskSetRequestCallCount() int

+ func (fake *FakeECSClient) DeleteTaskSetRequestCalls(...)

+ func (fake *FakeECSClient) DeleteTaskSetRequestReturns(result1 *request.Request, result2 *ecs.DeleteTaskSetOutput)

+ func (fake *FakeECSClient) DeleteTaskSetRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeleteTaskSetOutput)

+ func (fake *FakeECSClient) DeleteTaskSetReturns(result1 *ecs.DeleteTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) DeleteTaskSetReturnsOnCall(i int, result1 *ecs.DeleteTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) DeleteTaskSetWithContext(arg1 context.Context, arg2 *ecs.DeleteTaskSetInput, arg3 ...request.Option) (*ecs.DeleteTaskSetOutput, error)

+ func (fake *FakeECSClient) DeleteTaskSetWithContextArgsForCall(i int) (context.Context, *ecs.DeleteTaskSetInput, []request.Option)

+ func (fake *FakeECSClient) DeleteTaskSetWithContextCallCount() int

+ func (fake *FakeECSClient) DeleteTaskSetWithContextCalls(...)

+ func (fake *FakeECSClient) DeleteTaskSetWithContextReturns(result1 *ecs.DeleteTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) DeleteTaskSetWithContextReturnsOnCall(i int, result1 *ecs.DeleteTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterContainerInstance(arg1 *ecs.DeregisterContainerInstanceInput) (*ecs.DeregisterContainerInstanceOutput, error)

+ func (fake *FakeECSClient) DeregisterContainerInstanceArgsForCall(i int) *ecs.DeregisterContainerInstanceInput

+ func (fake *FakeECSClient) DeregisterContainerInstanceCallCount() int

+ func (fake *FakeECSClient) DeregisterContainerInstanceCalls(...)

+ func (fake *FakeECSClient) DeregisterContainerInstanceRequest(arg1 *ecs.DeregisterContainerInstanceInput) (*request.Request, *ecs.DeregisterContainerInstanceOutput)

+ func (fake *FakeECSClient) DeregisterContainerInstanceRequestArgsForCall(i int) *ecs.DeregisterContainerInstanceInput

+ func (fake *FakeECSClient) DeregisterContainerInstanceRequestCallCount() int

+ func (fake *FakeECSClient) DeregisterContainerInstanceRequestCalls(...)

+ func (fake *FakeECSClient) DeregisterContainerInstanceRequestReturns(result1 *request.Request, result2 *ecs.DeregisterContainerInstanceOutput)

+ func (fake *FakeECSClient) DeregisterContainerInstanceRequestReturnsOnCall(i int, result1 *request.Request, ...)

+ func (fake *FakeECSClient) DeregisterContainerInstanceReturns(result1 *ecs.DeregisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterContainerInstanceReturnsOnCall(i int, result1 *ecs.DeregisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterContainerInstanceWithContext(arg1 context.Context, arg2 *ecs.DeregisterContainerInstanceInput, ...) (*ecs.DeregisterContainerInstanceOutput, error)

+ func (fake *FakeECSClient) DeregisterContainerInstanceWithContextArgsForCall(i int) (context.Context, *ecs.DeregisterContainerInstanceInput, []request.Option)

+ func (fake *FakeECSClient) DeregisterContainerInstanceWithContextCallCount() int

+ func (fake *FakeECSClient) DeregisterContainerInstanceWithContextCalls(...)

+ func (fake *FakeECSClient) DeregisterContainerInstanceWithContextReturns(result1 *ecs.DeregisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterContainerInstanceWithContextReturnsOnCall(i int, result1 *ecs.DeregisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterTaskDefinition(arg1 *ecs.DeregisterTaskDefinitionInput) (*ecs.DeregisterTaskDefinitionOutput, error)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionArgsForCall(i int) *ecs.DeregisterTaskDefinitionInput

+ func (fake *FakeECSClient) DeregisterTaskDefinitionCallCount() int

+ func (fake *FakeECSClient) DeregisterTaskDefinitionCalls(...)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionRequest(arg1 *ecs.DeregisterTaskDefinitionInput) (*request.Request, *ecs.DeregisterTaskDefinitionOutput)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionRequestArgsForCall(i int) *ecs.DeregisterTaskDefinitionInput

+ func (fake *FakeECSClient) DeregisterTaskDefinitionRequestCallCount() int

+ func (fake *FakeECSClient) DeregisterTaskDefinitionRequestCalls(...)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionRequestReturns(result1 *request.Request, result2 *ecs.DeregisterTaskDefinitionOutput)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DeregisterTaskDefinitionOutput)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionReturns(result1 *ecs.DeregisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionReturnsOnCall(i int, result1 *ecs.DeregisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionWithContext(arg1 context.Context, arg2 *ecs.DeregisterTaskDefinitionInput, ...) (*ecs.DeregisterTaskDefinitionOutput, error)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionWithContextArgsForCall(i int) (context.Context, *ecs.DeregisterTaskDefinitionInput, []request.Option)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionWithContextCallCount() int

+ func (fake *FakeECSClient) DeregisterTaskDefinitionWithContextCalls(...)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionWithContextReturns(result1 *ecs.DeregisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DeregisterTaskDefinitionWithContextReturnsOnCall(i int, result1 *ecs.DeregisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DescribeCapacityProviders(arg1 *ecs.DescribeCapacityProvidersInput) (*ecs.DescribeCapacityProvidersOutput, error)

+ func (fake *FakeECSClient) DescribeCapacityProvidersArgsForCall(i int) *ecs.DescribeCapacityProvidersInput

+ func (fake *FakeECSClient) DescribeCapacityProvidersCallCount() int

+ func (fake *FakeECSClient) DescribeCapacityProvidersCalls(...)

+ func (fake *FakeECSClient) DescribeCapacityProvidersRequest(arg1 *ecs.DescribeCapacityProvidersInput) (*request.Request, *ecs.DescribeCapacityProvidersOutput)

+ func (fake *FakeECSClient) DescribeCapacityProvidersRequestArgsForCall(i int) *ecs.DescribeCapacityProvidersInput

+ func (fake *FakeECSClient) DescribeCapacityProvidersRequestCallCount() int

+ func (fake *FakeECSClient) DescribeCapacityProvidersRequestCalls(...)

+ func (fake *FakeECSClient) DescribeCapacityProvidersRequestReturns(result1 *request.Request, result2 *ecs.DescribeCapacityProvidersOutput)

+ func (fake *FakeECSClient) DescribeCapacityProvidersRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeCapacityProvidersOutput)

+ func (fake *FakeECSClient) DescribeCapacityProvidersReturns(result1 *ecs.DescribeCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeCapacityProvidersReturnsOnCall(i int, result1 *ecs.DescribeCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeCapacityProvidersWithContext(arg1 context.Context, arg2 *ecs.DescribeCapacityProvidersInput, ...) (*ecs.DescribeCapacityProvidersOutput, error)

+ func (fake *FakeECSClient) DescribeCapacityProvidersWithContextArgsForCall(i int) (context.Context, *ecs.DescribeCapacityProvidersInput, []request.Option)

+ func (fake *FakeECSClient) DescribeCapacityProvidersWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeCapacityProvidersWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeCapacityProvidersWithContextReturns(result1 *ecs.DescribeCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeCapacityProvidersWithContextReturnsOnCall(i int, result1 *ecs.DescribeCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeClusters(arg1 *ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error)

+ func (fake *FakeECSClient) DescribeClustersArgsForCall(i int) *ecs.DescribeClustersInput

+ func (fake *FakeECSClient) DescribeClustersCallCount() int

+ func (fake *FakeECSClient) DescribeClustersCalls(stub func(*ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error))

+ func (fake *FakeECSClient) DescribeClustersRequest(arg1 *ecs.DescribeClustersInput) (*request.Request, *ecs.DescribeClustersOutput)

+ func (fake *FakeECSClient) DescribeClustersRequestArgsForCall(i int) *ecs.DescribeClustersInput

+ func (fake *FakeECSClient) DescribeClustersRequestCallCount() int

+ func (fake *FakeECSClient) DescribeClustersRequestCalls(...)

+ func (fake *FakeECSClient) DescribeClustersRequestReturns(result1 *request.Request, result2 *ecs.DescribeClustersOutput)

+ func (fake *FakeECSClient) DescribeClustersRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeClustersOutput)

+ func (fake *FakeECSClient) DescribeClustersReturns(result1 *ecs.DescribeClustersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeClustersReturnsOnCall(i int, result1 *ecs.DescribeClustersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeClustersWithContext(arg1 context.Context, arg2 *ecs.DescribeClustersInput, arg3 ...request.Option) (*ecs.DescribeClustersOutput, error)

+ func (fake *FakeECSClient) DescribeClustersWithContextArgsForCall(i int) (context.Context, *ecs.DescribeClustersInput, []request.Option)

+ func (fake *FakeECSClient) DescribeClustersWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeClustersWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeClustersWithContextReturns(result1 *ecs.DescribeClustersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeClustersWithContextReturnsOnCall(i int, result1 *ecs.DescribeClustersOutput, result2 error)

+ func (fake *FakeECSClient) DescribeContainerInstances(arg1 *ecs.DescribeContainerInstancesInput) (*ecs.DescribeContainerInstancesOutput, error)

+ func (fake *FakeECSClient) DescribeContainerInstancesArgsForCall(i int) *ecs.DescribeContainerInstancesInput

+ func (fake *FakeECSClient) DescribeContainerInstancesCallCount() int

+ func (fake *FakeECSClient) DescribeContainerInstancesCalls(...)

+ func (fake *FakeECSClient) DescribeContainerInstancesRequest(arg1 *ecs.DescribeContainerInstancesInput) (*request.Request, *ecs.DescribeContainerInstancesOutput)

+ func (fake *FakeECSClient) DescribeContainerInstancesRequestArgsForCall(i int) *ecs.DescribeContainerInstancesInput

+ func (fake *FakeECSClient) DescribeContainerInstancesRequestCallCount() int

+ func (fake *FakeECSClient) DescribeContainerInstancesRequestCalls(...)

+ func (fake *FakeECSClient) DescribeContainerInstancesRequestReturns(result1 *request.Request, result2 *ecs.DescribeContainerInstancesOutput)

+ func (fake *FakeECSClient) DescribeContainerInstancesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeContainerInstancesOutput)

+ func (fake *FakeECSClient) DescribeContainerInstancesReturns(result1 *ecs.DescribeContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeContainerInstancesReturnsOnCall(i int, result1 *ecs.DescribeContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeContainerInstancesWithContext(arg1 context.Context, arg2 *ecs.DescribeContainerInstancesInput, ...) (*ecs.DescribeContainerInstancesOutput, error)

+ func (fake *FakeECSClient) DescribeContainerInstancesWithContextArgsForCall(i int) (context.Context, *ecs.DescribeContainerInstancesInput, []request.Option)

+ func (fake *FakeECSClient) DescribeContainerInstancesWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeContainerInstancesWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeContainerInstancesWithContextReturns(result1 *ecs.DescribeContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeContainerInstancesWithContextReturnsOnCall(i int, result1 *ecs.DescribeContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeServices(arg1 *ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error)

+ func (fake *FakeECSClient) DescribeServicesArgsForCall(i int) *ecs.DescribeServicesInput

+ func (fake *FakeECSClient) DescribeServicesCallCount() int

+ func (fake *FakeECSClient) DescribeServicesCalls(stub func(*ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error))

+ func (fake *FakeECSClient) DescribeServicesRequest(arg1 *ecs.DescribeServicesInput) (*request.Request, *ecs.DescribeServicesOutput)

+ func (fake *FakeECSClient) DescribeServicesRequestArgsForCall(i int) *ecs.DescribeServicesInput

+ func (fake *FakeECSClient) DescribeServicesRequestCallCount() int

+ func (fake *FakeECSClient) DescribeServicesRequestCalls(...)

+ func (fake *FakeECSClient) DescribeServicesRequestReturns(result1 *request.Request, result2 *ecs.DescribeServicesOutput)

+ func (fake *FakeECSClient) DescribeServicesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeServicesOutput)

+ func (fake *FakeECSClient) DescribeServicesReturns(result1 *ecs.DescribeServicesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeServicesReturnsOnCall(i int, result1 *ecs.DescribeServicesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeServicesWithContext(arg1 context.Context, arg2 *ecs.DescribeServicesInput, arg3 ...request.Option) (*ecs.DescribeServicesOutput, error)

+ func (fake *FakeECSClient) DescribeServicesWithContextArgsForCall(i int) (context.Context, *ecs.DescribeServicesInput, []request.Option)

+ func (fake *FakeECSClient) DescribeServicesWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeServicesWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeServicesWithContextReturns(result1 *ecs.DescribeServicesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeServicesWithContextReturnsOnCall(i int, result1 *ecs.DescribeServicesOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskDefinition(arg1 *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error)

+ func (fake *FakeECSClient) DescribeTaskDefinitionArgsForCall(i int) *ecs.DescribeTaskDefinitionInput

+ func (fake *FakeECSClient) DescribeTaskDefinitionCallCount() int

+ func (fake *FakeECSClient) DescribeTaskDefinitionCalls(...)

+ func (fake *FakeECSClient) DescribeTaskDefinitionRequest(arg1 *ecs.DescribeTaskDefinitionInput) (*request.Request, *ecs.DescribeTaskDefinitionOutput)

+ func (fake *FakeECSClient) DescribeTaskDefinitionRequestArgsForCall(i int) *ecs.DescribeTaskDefinitionInput

+ func (fake *FakeECSClient) DescribeTaskDefinitionRequestCallCount() int

+ func (fake *FakeECSClient) DescribeTaskDefinitionRequestCalls(...)

+ func (fake *FakeECSClient) DescribeTaskDefinitionRequestReturns(result1 *request.Request, result2 *ecs.DescribeTaskDefinitionOutput)

+ func (fake *FakeECSClient) DescribeTaskDefinitionRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeTaskDefinitionOutput)

+ func (fake *FakeECSClient) DescribeTaskDefinitionReturns(result1 *ecs.DescribeTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskDefinitionReturnsOnCall(i int, result1 *ecs.DescribeTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskDefinitionWithContext(arg1 context.Context, arg2 *ecs.DescribeTaskDefinitionInput, ...) (*ecs.DescribeTaskDefinitionOutput, error)

+ func (fake *FakeECSClient) DescribeTaskDefinitionWithContextArgsForCall(i int) (context.Context, *ecs.DescribeTaskDefinitionInput, []request.Option)

+ func (fake *FakeECSClient) DescribeTaskDefinitionWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeTaskDefinitionWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeTaskDefinitionWithContextReturns(result1 *ecs.DescribeTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskDefinitionWithContextReturnsOnCall(i int, result1 *ecs.DescribeTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskSets(arg1 *ecs.DescribeTaskSetsInput) (*ecs.DescribeTaskSetsOutput, error)

+ func (fake *FakeECSClient) DescribeTaskSetsArgsForCall(i int) *ecs.DescribeTaskSetsInput

+ func (fake *FakeECSClient) DescribeTaskSetsCallCount() int

+ func (fake *FakeECSClient) DescribeTaskSetsCalls(stub func(*ecs.DescribeTaskSetsInput) (*ecs.DescribeTaskSetsOutput, error))

+ func (fake *FakeECSClient) DescribeTaskSetsRequest(arg1 *ecs.DescribeTaskSetsInput) (*request.Request, *ecs.DescribeTaskSetsOutput)

+ func (fake *FakeECSClient) DescribeTaskSetsRequestArgsForCall(i int) *ecs.DescribeTaskSetsInput

+ func (fake *FakeECSClient) DescribeTaskSetsRequestCallCount() int

+ func (fake *FakeECSClient) DescribeTaskSetsRequestCalls(...)

+ func (fake *FakeECSClient) DescribeTaskSetsRequestReturns(result1 *request.Request, result2 *ecs.DescribeTaskSetsOutput)

+ func (fake *FakeECSClient) DescribeTaskSetsRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeTaskSetsOutput)

+ func (fake *FakeECSClient) DescribeTaskSetsReturns(result1 *ecs.DescribeTaskSetsOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskSetsReturnsOnCall(i int, result1 *ecs.DescribeTaskSetsOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskSetsWithContext(arg1 context.Context, arg2 *ecs.DescribeTaskSetsInput, arg3 ...request.Option) (*ecs.DescribeTaskSetsOutput, error)

+ func (fake *FakeECSClient) DescribeTaskSetsWithContextArgsForCall(i int) (context.Context, *ecs.DescribeTaskSetsInput, []request.Option)

+ func (fake *FakeECSClient) DescribeTaskSetsWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeTaskSetsWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeTaskSetsWithContextReturns(result1 *ecs.DescribeTaskSetsOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTaskSetsWithContextReturnsOnCall(i int, result1 *ecs.DescribeTaskSetsOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTasks(arg1 *ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error)

+ func (fake *FakeECSClient) DescribeTasksArgsForCall(i int) *ecs.DescribeTasksInput

+ func (fake *FakeECSClient) DescribeTasksCallCount() int

+ func (fake *FakeECSClient) DescribeTasksCalls(stub func(*ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error))

+ func (fake *FakeECSClient) DescribeTasksRequest(arg1 *ecs.DescribeTasksInput) (*request.Request, *ecs.DescribeTasksOutput)

+ func (fake *FakeECSClient) DescribeTasksRequestArgsForCall(i int) *ecs.DescribeTasksInput

+ func (fake *FakeECSClient) DescribeTasksRequestCallCount() int

+ func (fake *FakeECSClient) DescribeTasksRequestCalls(...)

+ func (fake *FakeECSClient) DescribeTasksRequestReturns(result1 *request.Request, result2 *ecs.DescribeTasksOutput)

+ func (fake *FakeECSClient) DescribeTasksRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DescribeTasksOutput)

+ func (fake *FakeECSClient) DescribeTasksReturns(result1 *ecs.DescribeTasksOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTasksReturnsOnCall(i int, result1 *ecs.DescribeTasksOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTasksWithContext(arg1 context.Context, arg2 *ecs.DescribeTasksInput, arg3 ...request.Option) (*ecs.DescribeTasksOutput, error)

+ func (fake *FakeECSClient) DescribeTasksWithContextArgsForCall(i int) (context.Context, *ecs.DescribeTasksInput, []request.Option)

+ func (fake *FakeECSClient) DescribeTasksWithContextCallCount() int

+ func (fake *FakeECSClient) DescribeTasksWithContextCalls(...)

+ func (fake *FakeECSClient) DescribeTasksWithContextReturns(result1 *ecs.DescribeTasksOutput, result2 error)

+ func (fake *FakeECSClient) DescribeTasksWithContextReturnsOnCall(i int, result1 *ecs.DescribeTasksOutput, result2 error)

+ func (fake *FakeECSClient) DiscoverPollEndpoint(arg1 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error)

+ func (fake *FakeECSClient) DiscoverPollEndpointArgsForCall(i int) *ecs.DiscoverPollEndpointInput

+ func (fake *FakeECSClient) DiscoverPollEndpointCallCount() int

+ func (fake *FakeECSClient) DiscoverPollEndpointCalls(...)

+ func (fake *FakeECSClient) DiscoverPollEndpointRequest(arg1 *ecs.DiscoverPollEndpointInput) (*request.Request, *ecs.DiscoverPollEndpointOutput)

+ func (fake *FakeECSClient) DiscoverPollEndpointRequestArgsForCall(i int) *ecs.DiscoverPollEndpointInput

+ func (fake *FakeECSClient) DiscoverPollEndpointRequestCallCount() int

+ func (fake *FakeECSClient) DiscoverPollEndpointRequestCalls(...)

+ func (fake *FakeECSClient) DiscoverPollEndpointRequestReturns(result1 *request.Request, result2 *ecs.DiscoverPollEndpointOutput)

+ func (fake *FakeECSClient) DiscoverPollEndpointRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.DiscoverPollEndpointOutput)

+ func (fake *FakeECSClient) DiscoverPollEndpointReturns(result1 *ecs.DiscoverPollEndpointOutput, result2 error)

+ func (fake *FakeECSClient) DiscoverPollEndpointReturnsOnCall(i int, result1 *ecs.DiscoverPollEndpointOutput, result2 error)

+ func (fake *FakeECSClient) DiscoverPollEndpointWithContext(arg1 context.Context, arg2 *ecs.DiscoverPollEndpointInput, ...) (*ecs.DiscoverPollEndpointOutput, error)

+ func (fake *FakeECSClient) DiscoverPollEndpointWithContextArgsForCall(i int) (context.Context, *ecs.DiscoverPollEndpointInput, []request.Option)

+ func (fake *FakeECSClient) DiscoverPollEndpointWithContextCallCount() int

+ func (fake *FakeECSClient) DiscoverPollEndpointWithContextCalls(...)

+ func (fake *FakeECSClient) DiscoverPollEndpointWithContextReturns(result1 *ecs.DiscoverPollEndpointOutput, result2 error)

+ func (fake *FakeECSClient) DiscoverPollEndpointWithContextReturnsOnCall(i int, result1 *ecs.DiscoverPollEndpointOutput, result2 error)

+ func (fake *FakeECSClient) Invocations() map[string][][]interface{}

+ func (fake *FakeECSClient) ListAccountSettings(arg1 *ecs.ListAccountSettingsInput) (*ecs.ListAccountSettingsOutput, error)

+ func (fake *FakeECSClient) ListAccountSettingsArgsForCall(i int) *ecs.ListAccountSettingsInput

+ func (fake *FakeECSClient) ListAccountSettingsCallCount() int

+ func (fake *FakeECSClient) ListAccountSettingsCalls(...)

+ func (fake *FakeECSClient) ListAccountSettingsPages(arg1 *ecs.ListAccountSettingsInput, ...) error

+ func (fake *FakeECSClient) ListAccountSettingsPagesArgsForCall(i int) (*ecs.ListAccountSettingsInput, func(*ecs.ListAccountSettingsOutput, bool) bool)

+ func (fake *FakeECSClient) ListAccountSettingsPagesCallCount() int

+ func (fake *FakeECSClient) ListAccountSettingsPagesCalls(...)

+ func (fake *FakeECSClient) ListAccountSettingsPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListAccountSettingsPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListAccountSettingsPagesWithContext(arg1 context.Context, arg2 *ecs.ListAccountSettingsInput, ...) error

+ func (fake *FakeECSClient) ListAccountSettingsPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListAccountSettingsInput, ...)

+ func (fake *FakeECSClient) ListAccountSettingsPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListAccountSettingsPagesWithContextCalls(stub func(context.Context, *ecs.ListAccountSettingsInput, ...) error)

+ func (fake *FakeECSClient) ListAccountSettingsPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListAccountSettingsPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListAccountSettingsRequest(arg1 *ecs.ListAccountSettingsInput) (*request.Request, *ecs.ListAccountSettingsOutput)

+ func (fake *FakeECSClient) ListAccountSettingsRequestArgsForCall(i int) *ecs.ListAccountSettingsInput

+ func (fake *FakeECSClient) ListAccountSettingsRequestCallCount() int

+ func (fake *FakeECSClient) ListAccountSettingsRequestCalls(...)

+ func (fake *FakeECSClient) ListAccountSettingsRequestReturns(result1 *request.Request, result2 *ecs.ListAccountSettingsOutput)

+ func (fake *FakeECSClient) ListAccountSettingsRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListAccountSettingsOutput)

+ func (fake *FakeECSClient) ListAccountSettingsReturns(result1 *ecs.ListAccountSettingsOutput, result2 error)

+ func (fake *FakeECSClient) ListAccountSettingsReturnsOnCall(i int, result1 *ecs.ListAccountSettingsOutput, result2 error)

+ func (fake *FakeECSClient) ListAccountSettingsWithContext(arg1 context.Context, arg2 *ecs.ListAccountSettingsInput, ...) (*ecs.ListAccountSettingsOutput, error)

+ func (fake *FakeECSClient) ListAccountSettingsWithContextArgsForCall(i int) (context.Context, *ecs.ListAccountSettingsInput, []request.Option)

+ func (fake *FakeECSClient) ListAccountSettingsWithContextCallCount() int

+ func (fake *FakeECSClient) ListAccountSettingsWithContextCalls(...)

+ func (fake *FakeECSClient) ListAccountSettingsWithContextReturns(result1 *ecs.ListAccountSettingsOutput, result2 error)

+ func (fake *FakeECSClient) ListAccountSettingsWithContextReturnsOnCall(i int, result1 *ecs.ListAccountSettingsOutput, result2 error)

+ func (fake *FakeECSClient) ListAttributes(arg1 *ecs.ListAttributesInput) (*ecs.ListAttributesOutput, error)

+ func (fake *FakeECSClient) ListAttributesArgsForCall(i int) *ecs.ListAttributesInput

+ func (fake *FakeECSClient) ListAttributesCallCount() int

+ func (fake *FakeECSClient) ListAttributesCalls(stub func(*ecs.ListAttributesInput) (*ecs.ListAttributesOutput, error))

+ func (fake *FakeECSClient) ListAttributesPages(arg1 *ecs.ListAttributesInput, arg2 func(*ecs.ListAttributesOutput, bool) bool) error

+ func (fake *FakeECSClient) ListAttributesPagesArgsForCall(i int) (*ecs.ListAttributesInput, func(*ecs.ListAttributesOutput, bool) bool)

+ func (fake *FakeECSClient) ListAttributesPagesCallCount() int

+ func (fake *FakeECSClient) ListAttributesPagesCalls(...)

+ func (fake *FakeECSClient) ListAttributesPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListAttributesPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListAttributesPagesWithContext(arg1 context.Context, arg2 *ecs.ListAttributesInput, ...) error

+ func (fake *FakeECSClient) ListAttributesPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListAttributesInput, ...)

+ func (fake *FakeECSClient) ListAttributesPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListAttributesPagesWithContextCalls(stub func(context.Context, *ecs.ListAttributesInput, ...) error)

+ func (fake *FakeECSClient) ListAttributesPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListAttributesPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListAttributesRequest(arg1 *ecs.ListAttributesInput) (*request.Request, *ecs.ListAttributesOutput)

+ func (fake *FakeECSClient) ListAttributesRequestArgsForCall(i int) *ecs.ListAttributesInput

+ func (fake *FakeECSClient) ListAttributesRequestCallCount() int

+ func (fake *FakeECSClient) ListAttributesRequestCalls(...)

+ func (fake *FakeECSClient) ListAttributesRequestReturns(result1 *request.Request, result2 *ecs.ListAttributesOutput)

+ func (fake *FakeECSClient) ListAttributesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListAttributesOutput)

+ func (fake *FakeECSClient) ListAttributesReturns(result1 *ecs.ListAttributesOutput, result2 error)

+ func (fake *FakeECSClient) ListAttributesReturnsOnCall(i int, result1 *ecs.ListAttributesOutput, result2 error)

+ func (fake *FakeECSClient) ListAttributesWithContext(arg1 context.Context, arg2 *ecs.ListAttributesInput, arg3 ...request.Option) (*ecs.ListAttributesOutput, error)

+ func (fake *FakeECSClient) ListAttributesWithContextArgsForCall(i int) (context.Context, *ecs.ListAttributesInput, []request.Option)

+ func (fake *FakeECSClient) ListAttributesWithContextCallCount() int

+ func (fake *FakeECSClient) ListAttributesWithContextCalls(...)

+ func (fake *FakeECSClient) ListAttributesWithContextReturns(result1 *ecs.ListAttributesOutput, result2 error)

+ func (fake *FakeECSClient) ListAttributesWithContextReturnsOnCall(i int, result1 *ecs.ListAttributesOutput, result2 error)

+ func (fake *FakeECSClient) ListClusters(arg1 *ecs.ListClustersInput) (*ecs.ListClustersOutput, error)

+ func (fake *FakeECSClient) ListClustersArgsForCall(i int) *ecs.ListClustersInput

+ func (fake *FakeECSClient) ListClustersCallCount() int

+ func (fake *FakeECSClient) ListClustersCalls(stub func(*ecs.ListClustersInput) (*ecs.ListClustersOutput, error))

+ func (fake *FakeECSClient) ListClustersPages(arg1 *ecs.ListClustersInput, arg2 func(*ecs.ListClustersOutput, bool) bool) error

+ func (fake *FakeECSClient) ListClustersPagesArgsForCall(i int) (*ecs.ListClustersInput, func(*ecs.ListClustersOutput, bool) bool)

+ func (fake *FakeECSClient) ListClustersPagesCallCount() int

+ func (fake *FakeECSClient) ListClustersPagesCalls(...)

+ func (fake *FakeECSClient) ListClustersPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListClustersPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListClustersPagesWithContext(arg1 context.Context, arg2 *ecs.ListClustersInput, ...) error

+ func (fake *FakeECSClient) ListClustersPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListClustersInput, ...)

+ func (fake *FakeECSClient) ListClustersPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListClustersPagesWithContextCalls(stub func(context.Context, *ecs.ListClustersInput, ...) error)

+ func (fake *FakeECSClient) ListClustersPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListClustersPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListClustersRequest(arg1 *ecs.ListClustersInput) (*request.Request, *ecs.ListClustersOutput)

+ func (fake *FakeECSClient) ListClustersRequestArgsForCall(i int) *ecs.ListClustersInput

+ func (fake *FakeECSClient) ListClustersRequestCallCount() int

+ func (fake *FakeECSClient) ListClustersRequestCalls(stub func(*ecs.ListClustersInput) (*request.Request, *ecs.ListClustersOutput))

+ func (fake *FakeECSClient) ListClustersRequestReturns(result1 *request.Request, result2 *ecs.ListClustersOutput)

+ func (fake *FakeECSClient) ListClustersRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListClustersOutput)

+ func (fake *FakeECSClient) ListClustersReturns(result1 *ecs.ListClustersOutput, result2 error)

+ func (fake *FakeECSClient) ListClustersReturnsOnCall(i int, result1 *ecs.ListClustersOutput, result2 error)

+ func (fake *FakeECSClient) ListClustersWithContext(arg1 context.Context, arg2 *ecs.ListClustersInput, arg3 ...request.Option) (*ecs.ListClustersOutput, error)

+ func (fake *FakeECSClient) ListClustersWithContextArgsForCall(i int) (context.Context, *ecs.ListClustersInput, []request.Option)

+ func (fake *FakeECSClient) ListClustersWithContextCallCount() int

+ func (fake *FakeECSClient) ListClustersWithContextCalls(...)

+ func (fake *FakeECSClient) ListClustersWithContextReturns(result1 *ecs.ListClustersOutput, result2 error)

+ func (fake *FakeECSClient) ListClustersWithContextReturnsOnCall(i int, result1 *ecs.ListClustersOutput, result2 error)

+ func (fake *FakeECSClient) ListContainerInstances(arg1 *ecs.ListContainerInstancesInput) (*ecs.ListContainerInstancesOutput, error)

+ func (fake *FakeECSClient) ListContainerInstancesArgsForCall(i int) *ecs.ListContainerInstancesInput

+ func (fake *FakeECSClient) ListContainerInstancesCallCount() int

+ func (fake *FakeECSClient) ListContainerInstancesCalls(...)

+ func (fake *FakeECSClient) ListContainerInstancesPages(arg1 *ecs.ListContainerInstancesInput, ...) error

+ func (fake *FakeECSClient) ListContainerInstancesPagesArgsForCall(i int) (*ecs.ListContainerInstancesInput, ...)

+ func (fake *FakeECSClient) ListContainerInstancesPagesCallCount() int

+ func (fake *FakeECSClient) ListContainerInstancesPagesCalls(stub func(*ecs.ListContainerInstancesInput, ...) error)

+ func (fake *FakeECSClient) ListContainerInstancesPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListContainerInstancesPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListContainerInstancesPagesWithContext(arg1 context.Context, arg2 *ecs.ListContainerInstancesInput, ...) error

+ func (fake *FakeECSClient) ListContainerInstancesPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListContainerInstancesInput, ...)

+ func (fake *FakeECSClient) ListContainerInstancesPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListContainerInstancesPagesWithContextCalls(stub func(context.Context, *ecs.ListContainerInstancesInput, ...) error)

+ func (fake *FakeECSClient) ListContainerInstancesPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListContainerInstancesPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListContainerInstancesRequest(arg1 *ecs.ListContainerInstancesInput) (*request.Request, *ecs.ListContainerInstancesOutput)

+ func (fake *FakeECSClient) ListContainerInstancesRequestArgsForCall(i int) *ecs.ListContainerInstancesInput

+ func (fake *FakeECSClient) ListContainerInstancesRequestCallCount() int

+ func (fake *FakeECSClient) ListContainerInstancesRequestCalls(...)

+ func (fake *FakeECSClient) ListContainerInstancesRequestReturns(result1 *request.Request, result2 *ecs.ListContainerInstancesOutput)

+ func (fake *FakeECSClient) ListContainerInstancesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListContainerInstancesOutput)

+ func (fake *FakeECSClient) ListContainerInstancesReturns(result1 *ecs.ListContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) ListContainerInstancesReturnsOnCall(i int, result1 *ecs.ListContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) ListContainerInstancesWithContext(arg1 context.Context, arg2 *ecs.ListContainerInstancesInput, ...) (*ecs.ListContainerInstancesOutput, error)

+ func (fake *FakeECSClient) ListContainerInstancesWithContextArgsForCall(i int) (context.Context, *ecs.ListContainerInstancesInput, []request.Option)

+ func (fake *FakeECSClient) ListContainerInstancesWithContextCallCount() int

+ func (fake *FakeECSClient) ListContainerInstancesWithContextCalls(...)

+ func (fake *FakeECSClient) ListContainerInstancesWithContextReturns(result1 *ecs.ListContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) ListContainerInstancesWithContextReturnsOnCall(i int, result1 *ecs.ListContainerInstancesOutput, result2 error)

+ func (fake *FakeECSClient) ListServices(arg1 *ecs.ListServicesInput) (*ecs.ListServicesOutput, error)

+ func (fake *FakeECSClient) ListServicesArgsForCall(i int) *ecs.ListServicesInput

+ func (fake *FakeECSClient) ListServicesCallCount() int

+ func (fake *FakeECSClient) ListServicesCalls(stub func(*ecs.ListServicesInput) (*ecs.ListServicesOutput, error))

+ func (fake *FakeECSClient) ListServicesPages(arg1 *ecs.ListServicesInput, arg2 func(*ecs.ListServicesOutput, bool) bool) error

+ func (fake *FakeECSClient) ListServicesPagesArgsForCall(i int) (*ecs.ListServicesInput, func(*ecs.ListServicesOutput, bool) bool)

+ func (fake *FakeECSClient) ListServicesPagesCallCount() int

+ func (fake *FakeECSClient) ListServicesPagesCalls(...)

+ func (fake *FakeECSClient) ListServicesPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListServicesPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListServicesPagesWithContext(arg1 context.Context, arg2 *ecs.ListServicesInput, ...) error

+ func (fake *FakeECSClient) ListServicesPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListServicesInput, ...)

+ func (fake *FakeECSClient) ListServicesPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListServicesPagesWithContextCalls(stub func(context.Context, *ecs.ListServicesInput, ...) error)

+ func (fake *FakeECSClient) ListServicesPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListServicesPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListServicesRequest(arg1 *ecs.ListServicesInput) (*request.Request, *ecs.ListServicesOutput)

+ func (fake *FakeECSClient) ListServicesRequestArgsForCall(i int) *ecs.ListServicesInput

+ func (fake *FakeECSClient) ListServicesRequestCallCount() int

+ func (fake *FakeECSClient) ListServicesRequestCalls(stub func(*ecs.ListServicesInput) (*request.Request, *ecs.ListServicesOutput))

+ func (fake *FakeECSClient) ListServicesRequestReturns(result1 *request.Request, result2 *ecs.ListServicesOutput)

+ func (fake *FakeECSClient) ListServicesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListServicesOutput)

+ func (fake *FakeECSClient) ListServicesReturns(result1 *ecs.ListServicesOutput, result2 error)

+ func (fake *FakeECSClient) ListServicesReturnsOnCall(i int, result1 *ecs.ListServicesOutput, result2 error)

+ func (fake *FakeECSClient) ListServicesWithContext(arg1 context.Context, arg2 *ecs.ListServicesInput, arg3 ...request.Option) (*ecs.ListServicesOutput, error)

+ func (fake *FakeECSClient) ListServicesWithContextArgsForCall(i int) (context.Context, *ecs.ListServicesInput, []request.Option)

+ func (fake *FakeECSClient) ListServicesWithContextCallCount() int

+ func (fake *FakeECSClient) ListServicesWithContextCalls(...)

+ func (fake *FakeECSClient) ListServicesWithContextReturns(result1 *ecs.ListServicesOutput, result2 error)

+ func (fake *FakeECSClient) ListServicesWithContextReturnsOnCall(i int, result1 *ecs.ListServicesOutput, result2 error)

+ func (fake *FakeECSClient) ListTagsForResource(arg1 *ecs.ListTagsForResourceInput) (*ecs.ListTagsForResourceOutput, error)

+ func (fake *FakeECSClient) ListTagsForResourceArgsForCall(i int) *ecs.ListTagsForResourceInput

+ func (fake *FakeECSClient) ListTagsForResourceCallCount() int

+ func (fake *FakeECSClient) ListTagsForResourceCalls(...)

+ func (fake *FakeECSClient) ListTagsForResourceRequest(arg1 *ecs.ListTagsForResourceInput) (*request.Request, *ecs.ListTagsForResourceOutput)

+ func (fake *FakeECSClient) ListTagsForResourceRequestArgsForCall(i int) *ecs.ListTagsForResourceInput

+ func (fake *FakeECSClient) ListTagsForResourceRequestCallCount() int

+ func (fake *FakeECSClient) ListTagsForResourceRequestCalls(...)

+ func (fake *FakeECSClient) ListTagsForResourceRequestReturns(result1 *request.Request, result2 *ecs.ListTagsForResourceOutput)

+ func (fake *FakeECSClient) ListTagsForResourceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListTagsForResourceOutput)

+ func (fake *FakeECSClient) ListTagsForResourceReturns(result1 *ecs.ListTagsForResourceOutput, result2 error)

+ func (fake *FakeECSClient) ListTagsForResourceReturnsOnCall(i int, result1 *ecs.ListTagsForResourceOutput, result2 error)

+ func (fake *FakeECSClient) ListTagsForResourceWithContext(arg1 context.Context, arg2 *ecs.ListTagsForResourceInput, ...) (*ecs.ListTagsForResourceOutput, error)

+ func (fake *FakeECSClient) ListTagsForResourceWithContextArgsForCall(i int) (context.Context, *ecs.ListTagsForResourceInput, []request.Option)

+ func (fake *FakeECSClient) ListTagsForResourceWithContextCallCount() int

+ func (fake *FakeECSClient) ListTagsForResourceWithContextCalls(...)

+ func (fake *FakeECSClient) ListTagsForResourceWithContextReturns(result1 *ecs.ListTagsForResourceOutput, result2 error)

+ func (fake *FakeECSClient) ListTagsForResourceWithContextReturnsOnCall(i int, result1 *ecs.ListTagsForResourceOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamilies(arg1 *ecs.ListTaskDefinitionFamiliesInput) (*ecs.ListTaskDefinitionFamiliesOutput, error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesArgsForCall(i int) *ecs.ListTaskDefinitionFamiliesInput

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPages(arg1 *ecs.ListTaskDefinitionFamiliesInput, ...) error

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesArgsForCall(i int) (*ecs.ListTaskDefinitionFamiliesInput, ...)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesCalls(stub func(*ecs.ListTaskDefinitionFamiliesInput, ...) error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesWithContext(arg1 context.Context, arg2 *ecs.ListTaskDefinitionFamiliesInput, ...) error

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListTaskDefinitionFamiliesInput, ...)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesWithContextCalls(stub func(context.Context, *ecs.ListTaskDefinitionFamiliesInput, ...) error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesRequest(arg1 *ecs.ListTaskDefinitionFamiliesInput) (*request.Request, *ecs.ListTaskDefinitionFamiliesOutput)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesRequestArgsForCall(i int) *ecs.ListTaskDefinitionFamiliesInput

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesRequestCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesRequestCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesRequestReturns(result1 *request.Request, result2 *ecs.ListTaskDefinitionFamiliesOutput)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListTaskDefinitionFamiliesOutput)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesReturns(result1 *ecs.ListTaskDefinitionFamiliesOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesReturnsOnCall(i int, result1 *ecs.ListTaskDefinitionFamiliesOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesWithContext(arg1 context.Context, arg2 *ecs.ListTaskDefinitionFamiliesInput, ...) (*ecs.ListTaskDefinitionFamiliesOutput, error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesWithContextArgsForCall(i int) (context.Context, *ecs.ListTaskDefinitionFamiliesInput, []request.Option)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesWithContextCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesWithContextCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesWithContextReturns(result1 *ecs.ListTaskDefinitionFamiliesOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionFamiliesWithContextReturnsOnCall(i int, result1 *ecs.ListTaskDefinitionFamiliesOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitions(arg1 *ecs.ListTaskDefinitionsInput) (*ecs.ListTaskDefinitionsOutput, error)

+ func (fake *FakeECSClient) ListTaskDefinitionsArgsForCall(i int) *ecs.ListTaskDefinitionsInput

+ func (fake *FakeECSClient) ListTaskDefinitionsCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionsCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionsPages(arg1 *ecs.ListTaskDefinitionsInput, ...) error

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesArgsForCall(i int) (*ecs.ListTaskDefinitionsInput, func(*ecs.ListTaskDefinitionsOutput, bool) bool)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesWithContext(arg1 context.Context, arg2 *ecs.ListTaskDefinitionsInput, ...) error

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListTaskDefinitionsInput, ...)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesWithContextCalls(stub func(context.Context, *ecs.ListTaskDefinitionsInput, ...) error)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsRequest(arg1 *ecs.ListTaskDefinitionsInput) (*request.Request, *ecs.ListTaskDefinitionsOutput)

+ func (fake *FakeECSClient) ListTaskDefinitionsRequestArgsForCall(i int) *ecs.ListTaskDefinitionsInput

+ func (fake *FakeECSClient) ListTaskDefinitionsRequestCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionsRequestCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionsRequestReturns(result1 *request.Request, result2 *ecs.ListTaskDefinitionsOutput)

+ func (fake *FakeECSClient) ListTaskDefinitionsRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListTaskDefinitionsOutput)

+ func (fake *FakeECSClient) ListTaskDefinitionsReturns(result1 *ecs.ListTaskDefinitionsOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsReturnsOnCall(i int, result1 *ecs.ListTaskDefinitionsOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsWithContext(arg1 context.Context, arg2 *ecs.ListTaskDefinitionsInput, ...) (*ecs.ListTaskDefinitionsOutput, error)

+ func (fake *FakeECSClient) ListTaskDefinitionsWithContextArgsForCall(i int) (context.Context, *ecs.ListTaskDefinitionsInput, []request.Option)

+ func (fake *FakeECSClient) ListTaskDefinitionsWithContextCallCount() int

+ func (fake *FakeECSClient) ListTaskDefinitionsWithContextCalls(...)

+ func (fake *FakeECSClient) ListTaskDefinitionsWithContextReturns(result1 *ecs.ListTaskDefinitionsOutput, result2 error)

+ func (fake *FakeECSClient) ListTaskDefinitionsWithContextReturnsOnCall(i int, result1 *ecs.ListTaskDefinitionsOutput, result2 error)

+ func (fake *FakeECSClient) ListTasks(arg1 *ecs.ListTasksInput) (*ecs.ListTasksOutput, error)

+ func (fake *FakeECSClient) ListTasksArgsForCall(i int) *ecs.ListTasksInput

+ func (fake *FakeECSClient) ListTasksCallCount() int

+ func (fake *FakeECSClient) ListTasksCalls(stub func(*ecs.ListTasksInput) (*ecs.ListTasksOutput, error))

+ func (fake *FakeECSClient) ListTasksPages(arg1 *ecs.ListTasksInput, arg2 func(*ecs.ListTasksOutput, bool) bool) error

+ func (fake *FakeECSClient) ListTasksPagesArgsForCall(i int) (*ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool)

+ func (fake *FakeECSClient) ListTasksPagesCallCount() int

+ func (fake *FakeECSClient) ListTasksPagesCalls(stub func(*ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool) error)

+ func (fake *FakeECSClient) ListTasksPagesReturns(result1 error)

+ func (fake *FakeECSClient) ListTasksPagesReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListTasksPagesWithContext(arg1 context.Context, arg2 *ecs.ListTasksInput, ...) error

+ func (fake *FakeECSClient) ListTasksPagesWithContextArgsForCall(i int) (context.Context, *ecs.ListTasksInput, func(*ecs.ListTasksOutput, bool) bool, ...)

+ func (fake *FakeECSClient) ListTasksPagesWithContextCallCount() int

+ func (fake *FakeECSClient) ListTasksPagesWithContextCalls(...)

+ func (fake *FakeECSClient) ListTasksPagesWithContextReturns(result1 error)

+ func (fake *FakeECSClient) ListTasksPagesWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) ListTasksRequest(arg1 *ecs.ListTasksInput) (*request.Request, *ecs.ListTasksOutput)

+ func (fake *FakeECSClient) ListTasksRequestArgsForCall(i int) *ecs.ListTasksInput

+ func (fake *FakeECSClient) ListTasksRequestCallCount() int

+ func (fake *FakeECSClient) ListTasksRequestCalls(stub func(*ecs.ListTasksInput) (*request.Request, *ecs.ListTasksOutput))

+ func (fake *FakeECSClient) ListTasksRequestReturns(result1 *request.Request, result2 *ecs.ListTasksOutput)

+ func (fake *FakeECSClient) ListTasksRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.ListTasksOutput)

+ func (fake *FakeECSClient) ListTasksReturns(result1 *ecs.ListTasksOutput, result2 error)

+ func (fake *FakeECSClient) ListTasksReturnsOnCall(i int, result1 *ecs.ListTasksOutput, result2 error)

+ func (fake *FakeECSClient) ListTasksWithContext(arg1 context.Context, arg2 *ecs.ListTasksInput, arg3 ...request.Option) (*ecs.ListTasksOutput, error)

+ func (fake *FakeECSClient) ListTasksWithContextArgsForCall(i int) (context.Context, *ecs.ListTasksInput, []request.Option)

+ func (fake *FakeECSClient) ListTasksWithContextCallCount() int

+ func (fake *FakeECSClient) ListTasksWithContextCalls(...)

+ func (fake *FakeECSClient) ListTasksWithContextReturns(result1 *ecs.ListTasksOutput, result2 error)

+ func (fake *FakeECSClient) ListTasksWithContextReturnsOnCall(i int, result1 *ecs.ListTasksOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSetting(arg1 *ecs.PutAccountSettingInput) (*ecs.PutAccountSettingOutput, error)

+ func (fake *FakeECSClient) PutAccountSettingArgsForCall(i int) *ecs.PutAccountSettingInput

+ func (fake *FakeECSClient) PutAccountSettingCallCount() int

+ func (fake *FakeECSClient) PutAccountSettingCalls(stub func(*ecs.PutAccountSettingInput) (*ecs.PutAccountSettingOutput, error))

+ func (fake *FakeECSClient) PutAccountSettingDefault(arg1 *ecs.PutAccountSettingDefaultInput) (*ecs.PutAccountSettingDefaultOutput, error)

+ func (fake *FakeECSClient) PutAccountSettingDefaultArgsForCall(i int) *ecs.PutAccountSettingDefaultInput

+ func (fake *FakeECSClient) PutAccountSettingDefaultCallCount() int

+ func (fake *FakeECSClient) PutAccountSettingDefaultCalls(...)

+ func (fake *FakeECSClient) PutAccountSettingDefaultRequest(arg1 *ecs.PutAccountSettingDefaultInput) (*request.Request, *ecs.PutAccountSettingDefaultOutput)

+ func (fake *FakeECSClient) PutAccountSettingDefaultRequestArgsForCall(i int) *ecs.PutAccountSettingDefaultInput

+ func (fake *FakeECSClient) PutAccountSettingDefaultRequestCallCount() int

+ func (fake *FakeECSClient) PutAccountSettingDefaultRequestCalls(...)

+ func (fake *FakeECSClient) PutAccountSettingDefaultRequestReturns(result1 *request.Request, result2 *ecs.PutAccountSettingDefaultOutput)

+ func (fake *FakeECSClient) PutAccountSettingDefaultRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.PutAccountSettingDefaultOutput)

+ func (fake *FakeECSClient) PutAccountSettingDefaultReturns(result1 *ecs.PutAccountSettingDefaultOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingDefaultReturnsOnCall(i int, result1 *ecs.PutAccountSettingDefaultOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingDefaultWithContext(arg1 context.Context, arg2 *ecs.PutAccountSettingDefaultInput, ...) (*ecs.PutAccountSettingDefaultOutput, error)

+ func (fake *FakeECSClient) PutAccountSettingDefaultWithContextArgsForCall(i int) (context.Context, *ecs.PutAccountSettingDefaultInput, []request.Option)

+ func (fake *FakeECSClient) PutAccountSettingDefaultWithContextCallCount() int

+ func (fake *FakeECSClient) PutAccountSettingDefaultWithContextCalls(...)

+ func (fake *FakeECSClient) PutAccountSettingDefaultWithContextReturns(result1 *ecs.PutAccountSettingDefaultOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingDefaultWithContextReturnsOnCall(i int, result1 *ecs.PutAccountSettingDefaultOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingRequest(arg1 *ecs.PutAccountSettingInput) (*request.Request, *ecs.PutAccountSettingOutput)

+ func (fake *FakeECSClient) PutAccountSettingRequestArgsForCall(i int) *ecs.PutAccountSettingInput

+ func (fake *FakeECSClient) PutAccountSettingRequestCallCount() int

+ func (fake *FakeECSClient) PutAccountSettingRequestCalls(...)

+ func (fake *FakeECSClient) PutAccountSettingRequestReturns(result1 *request.Request, result2 *ecs.PutAccountSettingOutput)

+ func (fake *FakeECSClient) PutAccountSettingRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.PutAccountSettingOutput)

+ func (fake *FakeECSClient) PutAccountSettingReturns(result1 *ecs.PutAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingReturnsOnCall(i int, result1 *ecs.PutAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingWithContext(arg1 context.Context, arg2 *ecs.PutAccountSettingInput, arg3 ...request.Option) (*ecs.PutAccountSettingOutput, error)

+ func (fake *FakeECSClient) PutAccountSettingWithContextArgsForCall(i int) (context.Context, *ecs.PutAccountSettingInput, []request.Option)

+ func (fake *FakeECSClient) PutAccountSettingWithContextCallCount() int

+ func (fake *FakeECSClient) PutAccountSettingWithContextCalls(...)

+ func (fake *FakeECSClient) PutAccountSettingWithContextReturns(result1 *ecs.PutAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) PutAccountSettingWithContextReturnsOnCall(i int, result1 *ecs.PutAccountSettingOutput, result2 error)

+ func (fake *FakeECSClient) PutAttributes(arg1 *ecs.PutAttributesInput) (*ecs.PutAttributesOutput, error)

+ func (fake *FakeECSClient) PutAttributesArgsForCall(i int) *ecs.PutAttributesInput

+ func (fake *FakeECSClient) PutAttributesCallCount() int

+ func (fake *FakeECSClient) PutAttributesCalls(stub func(*ecs.PutAttributesInput) (*ecs.PutAttributesOutput, error))

+ func (fake *FakeECSClient) PutAttributesRequest(arg1 *ecs.PutAttributesInput) (*request.Request, *ecs.PutAttributesOutput)

+ func (fake *FakeECSClient) PutAttributesRequestArgsForCall(i int) *ecs.PutAttributesInput

+ func (fake *FakeECSClient) PutAttributesRequestCallCount() int

+ func (fake *FakeECSClient) PutAttributesRequestCalls(...)

+ func (fake *FakeECSClient) PutAttributesRequestReturns(result1 *request.Request, result2 *ecs.PutAttributesOutput)

+ func (fake *FakeECSClient) PutAttributesRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.PutAttributesOutput)

+ func (fake *FakeECSClient) PutAttributesReturns(result1 *ecs.PutAttributesOutput, result2 error)

+ func (fake *FakeECSClient) PutAttributesReturnsOnCall(i int, result1 *ecs.PutAttributesOutput, result2 error)

+ func (fake *FakeECSClient) PutAttributesWithContext(arg1 context.Context, arg2 *ecs.PutAttributesInput, arg3 ...request.Option) (*ecs.PutAttributesOutput, error)

+ func (fake *FakeECSClient) PutAttributesWithContextArgsForCall(i int) (context.Context, *ecs.PutAttributesInput, []request.Option)

+ func (fake *FakeECSClient) PutAttributesWithContextCallCount() int

+ func (fake *FakeECSClient) PutAttributesWithContextCalls(...)

+ func (fake *FakeECSClient) PutAttributesWithContextReturns(result1 *ecs.PutAttributesOutput, result2 error)

+ func (fake *FakeECSClient) PutAttributesWithContextReturnsOnCall(i int, result1 *ecs.PutAttributesOutput, result2 error)

+ func (fake *FakeECSClient) PutClusterCapacityProviders(arg1 *ecs.PutClusterCapacityProvidersInput) (*ecs.PutClusterCapacityProvidersOutput, error)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersArgsForCall(i int) *ecs.PutClusterCapacityProvidersInput

+ func (fake *FakeECSClient) PutClusterCapacityProvidersCallCount() int

+ func (fake *FakeECSClient) PutClusterCapacityProvidersCalls(...)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersRequest(arg1 *ecs.PutClusterCapacityProvidersInput) (*request.Request, *ecs.PutClusterCapacityProvidersOutput)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersRequestArgsForCall(i int) *ecs.PutClusterCapacityProvidersInput

+ func (fake *FakeECSClient) PutClusterCapacityProvidersRequestCallCount() int

+ func (fake *FakeECSClient) PutClusterCapacityProvidersRequestCalls(...)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersRequestReturns(result1 *request.Request, result2 *ecs.PutClusterCapacityProvidersOutput)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersRequestReturnsOnCall(i int, result1 *request.Request, ...)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersReturns(result1 *ecs.PutClusterCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersReturnsOnCall(i int, result1 *ecs.PutClusterCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersWithContext(arg1 context.Context, arg2 *ecs.PutClusterCapacityProvidersInput, ...) (*ecs.PutClusterCapacityProvidersOutput, error)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersWithContextArgsForCall(i int) (context.Context, *ecs.PutClusterCapacityProvidersInput, []request.Option)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersWithContextCallCount() int

+ func (fake *FakeECSClient) PutClusterCapacityProvidersWithContextCalls(...)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersWithContextReturns(result1 *ecs.PutClusterCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) PutClusterCapacityProvidersWithContextReturnsOnCall(i int, result1 *ecs.PutClusterCapacityProvidersOutput, result2 error)

+ func (fake *FakeECSClient) RegisterContainerInstance(arg1 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error)

+ func (fake *FakeECSClient) RegisterContainerInstanceArgsForCall(i int) *ecs.RegisterContainerInstanceInput

+ func (fake *FakeECSClient) RegisterContainerInstanceCallCount() int

+ func (fake *FakeECSClient) RegisterContainerInstanceCalls(...)

+ func (fake *FakeECSClient) RegisterContainerInstanceRequest(arg1 *ecs.RegisterContainerInstanceInput) (*request.Request, *ecs.RegisterContainerInstanceOutput)

+ func (fake *FakeECSClient) RegisterContainerInstanceRequestArgsForCall(i int) *ecs.RegisterContainerInstanceInput

+ func (fake *FakeECSClient) RegisterContainerInstanceRequestCallCount() int

+ func (fake *FakeECSClient) RegisterContainerInstanceRequestCalls(...)

+ func (fake *FakeECSClient) RegisterContainerInstanceRequestReturns(result1 *request.Request, result2 *ecs.RegisterContainerInstanceOutput)

+ func (fake *FakeECSClient) RegisterContainerInstanceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.RegisterContainerInstanceOutput)

+ func (fake *FakeECSClient) RegisterContainerInstanceReturns(result1 *ecs.RegisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) RegisterContainerInstanceReturnsOnCall(i int, result1 *ecs.RegisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) RegisterContainerInstanceWithContext(arg1 context.Context, arg2 *ecs.RegisterContainerInstanceInput, ...) (*ecs.RegisterContainerInstanceOutput, error)

+ func (fake *FakeECSClient) RegisterContainerInstanceWithContextArgsForCall(i int) (context.Context, *ecs.RegisterContainerInstanceInput, []request.Option)

+ func (fake *FakeECSClient) RegisterContainerInstanceWithContextCallCount() int

+ func (fake *FakeECSClient) RegisterContainerInstanceWithContextCalls(...)

+ func (fake *FakeECSClient) RegisterContainerInstanceWithContextReturns(result1 *ecs.RegisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) RegisterContainerInstanceWithContextReturnsOnCall(i int, result1 *ecs.RegisterContainerInstanceOutput, result2 error)

+ func (fake *FakeECSClient) RegisterTaskDefinition(arg1 *ecs.RegisterTaskDefinitionInput) (*ecs.RegisterTaskDefinitionOutput, error)

+ func (fake *FakeECSClient) RegisterTaskDefinitionArgsForCall(i int) *ecs.RegisterTaskDefinitionInput

+ func (fake *FakeECSClient) RegisterTaskDefinitionCallCount() int

+ func (fake *FakeECSClient) RegisterTaskDefinitionCalls(...)

+ func (fake *FakeECSClient) RegisterTaskDefinitionRequest(arg1 *ecs.RegisterTaskDefinitionInput) (*request.Request, *ecs.RegisterTaskDefinitionOutput)

+ func (fake *FakeECSClient) RegisterTaskDefinitionRequestArgsForCall(i int) *ecs.RegisterTaskDefinitionInput

+ func (fake *FakeECSClient) RegisterTaskDefinitionRequestCallCount() int

+ func (fake *FakeECSClient) RegisterTaskDefinitionRequestCalls(...)

+ func (fake *FakeECSClient) RegisterTaskDefinitionRequestReturns(result1 *request.Request, result2 *ecs.RegisterTaskDefinitionOutput)

+ func (fake *FakeECSClient) RegisterTaskDefinitionRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.RegisterTaskDefinitionOutput)

+ func (fake *FakeECSClient) RegisterTaskDefinitionReturns(result1 *ecs.RegisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) RegisterTaskDefinitionReturnsOnCall(i int, result1 *ecs.RegisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) RegisterTaskDefinitionWithContext(arg1 context.Context, arg2 *ecs.RegisterTaskDefinitionInput, ...) (*ecs.RegisterTaskDefinitionOutput, error)

+ func (fake *FakeECSClient) RegisterTaskDefinitionWithContextArgsForCall(i int) (context.Context, *ecs.RegisterTaskDefinitionInput, []request.Option)

+ func (fake *FakeECSClient) RegisterTaskDefinitionWithContextCallCount() int

+ func (fake *FakeECSClient) RegisterTaskDefinitionWithContextCalls(...)

+ func (fake *FakeECSClient) RegisterTaskDefinitionWithContextReturns(result1 *ecs.RegisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) RegisterTaskDefinitionWithContextReturnsOnCall(i int, result1 *ecs.RegisterTaskDefinitionOutput, result2 error)

+ func (fake *FakeECSClient) RunTask(arg1 *ecs.RunTaskInput) (*ecs.RunTaskOutput, error)

+ func (fake *FakeECSClient) RunTaskArgsForCall(i int) *ecs.RunTaskInput

+ func (fake *FakeECSClient) RunTaskCallCount() int

+ func (fake *FakeECSClient) RunTaskCalls(stub func(*ecs.RunTaskInput) (*ecs.RunTaskOutput, error))

+ func (fake *FakeECSClient) RunTaskRequest(arg1 *ecs.RunTaskInput) (*request.Request, *ecs.RunTaskOutput)

+ func (fake *FakeECSClient) RunTaskRequestArgsForCall(i int) *ecs.RunTaskInput

+ func (fake *FakeECSClient) RunTaskRequestCallCount() int

+ func (fake *FakeECSClient) RunTaskRequestCalls(stub func(*ecs.RunTaskInput) (*request.Request, *ecs.RunTaskOutput))

+ func (fake *FakeECSClient) RunTaskRequestReturns(result1 *request.Request, result2 *ecs.RunTaskOutput)

+ func (fake *FakeECSClient) RunTaskRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.RunTaskOutput)

+ func (fake *FakeECSClient) RunTaskReturns(result1 *ecs.RunTaskOutput, result2 error)

+ func (fake *FakeECSClient) RunTaskReturnsOnCall(i int, result1 *ecs.RunTaskOutput, result2 error)

+ func (fake *FakeECSClient) RunTaskWithContext(arg1 context.Context, arg2 *ecs.RunTaskInput, arg3 ...request.Option) (*ecs.RunTaskOutput, error)

+ func (fake *FakeECSClient) RunTaskWithContextArgsForCall(i int) (context.Context, *ecs.RunTaskInput, []request.Option)

+ func (fake *FakeECSClient) RunTaskWithContextCallCount() int

+ func (fake *FakeECSClient) RunTaskWithContextCalls(...)

+ func (fake *FakeECSClient) RunTaskWithContextReturns(result1 *ecs.RunTaskOutput, result2 error)

+ func (fake *FakeECSClient) RunTaskWithContextReturnsOnCall(i int, result1 *ecs.RunTaskOutput, result2 error)

+ func (fake *FakeECSClient) StartTask(arg1 *ecs.StartTaskInput) (*ecs.StartTaskOutput, error)

+ func (fake *FakeECSClient) StartTaskArgsForCall(i int) *ecs.StartTaskInput

+ func (fake *FakeECSClient) StartTaskCallCount() int

+ func (fake *FakeECSClient) StartTaskCalls(stub func(*ecs.StartTaskInput) (*ecs.StartTaskOutput, error))

+ func (fake *FakeECSClient) StartTaskRequest(arg1 *ecs.StartTaskInput) (*request.Request, *ecs.StartTaskOutput)

+ func (fake *FakeECSClient) StartTaskRequestArgsForCall(i int) *ecs.StartTaskInput

+ func (fake *FakeECSClient) StartTaskRequestCallCount() int

+ func (fake *FakeECSClient) StartTaskRequestCalls(stub func(*ecs.StartTaskInput) (*request.Request, *ecs.StartTaskOutput))

+ func (fake *FakeECSClient) StartTaskRequestReturns(result1 *request.Request, result2 *ecs.StartTaskOutput)

+ func (fake *FakeECSClient) StartTaskRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.StartTaskOutput)

+ func (fake *FakeECSClient) StartTaskReturns(result1 *ecs.StartTaskOutput, result2 error)

+ func (fake *FakeECSClient) StartTaskReturnsOnCall(i int, result1 *ecs.StartTaskOutput, result2 error)

+ func (fake *FakeECSClient) StartTaskWithContext(arg1 context.Context, arg2 *ecs.StartTaskInput, arg3 ...request.Option) (*ecs.StartTaskOutput, error)

+ func (fake *FakeECSClient) StartTaskWithContextArgsForCall(i int) (context.Context, *ecs.StartTaskInput, []request.Option)

+ func (fake *FakeECSClient) StartTaskWithContextCallCount() int

+ func (fake *FakeECSClient) StartTaskWithContextCalls(...)

+ func (fake *FakeECSClient) StartTaskWithContextReturns(result1 *ecs.StartTaskOutput, result2 error)

+ func (fake *FakeECSClient) StartTaskWithContextReturnsOnCall(i int, result1 *ecs.StartTaskOutput, result2 error)

+ func (fake *FakeECSClient) StopTask(arg1 *ecs.StopTaskInput) (*ecs.StopTaskOutput, error)

+ func (fake *FakeECSClient) StopTaskArgsForCall(i int) *ecs.StopTaskInput

+ func (fake *FakeECSClient) StopTaskCallCount() int

+ func (fake *FakeECSClient) StopTaskCalls(stub func(*ecs.StopTaskInput) (*ecs.StopTaskOutput, error))

+ func (fake *FakeECSClient) StopTaskRequest(arg1 *ecs.StopTaskInput) (*request.Request, *ecs.StopTaskOutput)

+ func (fake *FakeECSClient) StopTaskRequestArgsForCall(i int) *ecs.StopTaskInput

+ func (fake *FakeECSClient) StopTaskRequestCallCount() int

+ func (fake *FakeECSClient) StopTaskRequestCalls(stub func(*ecs.StopTaskInput) (*request.Request, *ecs.StopTaskOutput))

+ func (fake *FakeECSClient) StopTaskRequestReturns(result1 *request.Request, result2 *ecs.StopTaskOutput)

+ func (fake *FakeECSClient) StopTaskRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.StopTaskOutput)

+ func (fake *FakeECSClient) StopTaskReturns(result1 *ecs.StopTaskOutput, result2 error)

+ func (fake *FakeECSClient) StopTaskReturnsOnCall(i int, result1 *ecs.StopTaskOutput, result2 error)

+ func (fake *FakeECSClient) StopTaskWithContext(arg1 context.Context, arg2 *ecs.StopTaskInput, arg3 ...request.Option) (*ecs.StopTaskOutput, error)

+ func (fake *FakeECSClient) StopTaskWithContextArgsForCall(i int) (context.Context, *ecs.StopTaskInput, []request.Option)

+ func (fake *FakeECSClient) StopTaskWithContextCallCount() int

+ func (fake *FakeECSClient) StopTaskWithContextCalls(...)

+ func (fake *FakeECSClient) StopTaskWithContextReturns(result1 *ecs.StopTaskOutput, result2 error)

+ func (fake *FakeECSClient) StopTaskWithContextReturnsOnCall(i int, result1 *ecs.StopTaskOutput, result2 error)

+ func (fake *FakeECSClient) SubmitAttachmentStateChanges(arg1 *ecs.SubmitAttachmentStateChangesInput) (*ecs.SubmitAttachmentStateChangesOutput, error)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesArgsForCall(i int) *ecs.SubmitAttachmentStateChangesInput

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesCallCount() int

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesCalls(...)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesRequest(arg1 *ecs.SubmitAttachmentStateChangesInput) (*request.Request, *ecs.SubmitAttachmentStateChangesOutput)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesRequestArgsForCall(i int) *ecs.SubmitAttachmentStateChangesInput

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesRequestCallCount() int

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesRequestCalls(...)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesRequestReturns(result1 *request.Request, result2 *ecs.SubmitAttachmentStateChangesOutput)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesRequestReturnsOnCall(i int, result1 *request.Request, ...)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesReturns(result1 *ecs.SubmitAttachmentStateChangesOutput, result2 error)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesReturnsOnCall(i int, result1 *ecs.SubmitAttachmentStateChangesOutput, result2 error)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesWithContext(arg1 context.Context, arg2 *ecs.SubmitAttachmentStateChangesInput, ...) (*ecs.SubmitAttachmentStateChangesOutput, error)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesWithContextArgsForCall(i int) (context.Context, *ecs.SubmitAttachmentStateChangesInput, []request.Option)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesWithContextCallCount() int

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesWithContextCalls(...)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesWithContextReturns(result1 *ecs.SubmitAttachmentStateChangesOutput, result2 error)

+ func (fake *FakeECSClient) SubmitAttachmentStateChangesWithContextReturnsOnCall(i int, result1 *ecs.SubmitAttachmentStateChangesOutput, result2 error)

+ func (fake *FakeECSClient) SubmitContainerStateChange(arg1 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error)

+ func (fake *FakeECSClient) SubmitContainerStateChangeArgsForCall(i int) *ecs.SubmitContainerStateChangeInput

+ func (fake *FakeECSClient) SubmitContainerStateChangeCallCount() int

+ func (fake *FakeECSClient) SubmitContainerStateChangeCalls(...)

+ func (fake *FakeECSClient) SubmitContainerStateChangeRequest(arg1 *ecs.SubmitContainerStateChangeInput) (*request.Request, *ecs.SubmitContainerStateChangeOutput)

+ func (fake *FakeECSClient) SubmitContainerStateChangeRequestArgsForCall(i int) *ecs.SubmitContainerStateChangeInput

+ func (fake *FakeECSClient) SubmitContainerStateChangeRequestCallCount() int

+ func (fake *FakeECSClient) SubmitContainerStateChangeRequestCalls(...)

+ func (fake *FakeECSClient) SubmitContainerStateChangeRequestReturns(result1 *request.Request, result2 *ecs.SubmitContainerStateChangeOutput)

+ func (fake *FakeECSClient) SubmitContainerStateChangeRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.SubmitContainerStateChangeOutput)

+ func (fake *FakeECSClient) SubmitContainerStateChangeReturns(result1 *ecs.SubmitContainerStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitContainerStateChangeReturnsOnCall(i int, result1 *ecs.SubmitContainerStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitContainerStateChangeWithContext(arg1 context.Context, arg2 *ecs.SubmitContainerStateChangeInput, ...) (*ecs.SubmitContainerStateChangeOutput, error)

+ func (fake *FakeECSClient) SubmitContainerStateChangeWithContextArgsForCall(i int) (context.Context, *ecs.SubmitContainerStateChangeInput, []request.Option)

+ func (fake *FakeECSClient) SubmitContainerStateChangeWithContextCallCount() int

+ func (fake *FakeECSClient) SubmitContainerStateChangeWithContextCalls(...)

+ func (fake *FakeECSClient) SubmitContainerStateChangeWithContextReturns(result1 *ecs.SubmitContainerStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitContainerStateChangeWithContextReturnsOnCall(i int, result1 *ecs.SubmitContainerStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitTaskStateChange(arg1 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error)

+ func (fake *FakeECSClient) SubmitTaskStateChangeArgsForCall(i int) *ecs.SubmitTaskStateChangeInput

+ func (fake *FakeECSClient) SubmitTaskStateChangeCallCount() int

+ func (fake *FakeECSClient) SubmitTaskStateChangeCalls(...)

+ func (fake *FakeECSClient) SubmitTaskStateChangeRequest(arg1 *ecs.SubmitTaskStateChangeInput) (*request.Request, *ecs.SubmitTaskStateChangeOutput)

+ func (fake *FakeECSClient) SubmitTaskStateChangeRequestArgsForCall(i int) *ecs.SubmitTaskStateChangeInput

+ func (fake *FakeECSClient) SubmitTaskStateChangeRequestCallCount() int

+ func (fake *FakeECSClient) SubmitTaskStateChangeRequestCalls(...)

+ func (fake *FakeECSClient) SubmitTaskStateChangeRequestReturns(result1 *request.Request, result2 *ecs.SubmitTaskStateChangeOutput)

+ func (fake *FakeECSClient) SubmitTaskStateChangeRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.SubmitTaskStateChangeOutput)

+ func (fake *FakeECSClient) SubmitTaskStateChangeReturns(result1 *ecs.SubmitTaskStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitTaskStateChangeReturnsOnCall(i int, result1 *ecs.SubmitTaskStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitTaskStateChangeWithContext(arg1 context.Context, arg2 *ecs.SubmitTaskStateChangeInput, ...) (*ecs.SubmitTaskStateChangeOutput, error)

+ func (fake *FakeECSClient) SubmitTaskStateChangeWithContextArgsForCall(i int) (context.Context, *ecs.SubmitTaskStateChangeInput, []request.Option)

+ func (fake *FakeECSClient) SubmitTaskStateChangeWithContextCallCount() int

+ func (fake *FakeECSClient) SubmitTaskStateChangeWithContextCalls(...)

+ func (fake *FakeECSClient) SubmitTaskStateChangeWithContextReturns(result1 *ecs.SubmitTaskStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) SubmitTaskStateChangeWithContextReturnsOnCall(i int, result1 *ecs.SubmitTaskStateChangeOutput, result2 error)

+ func (fake *FakeECSClient) TagResource(arg1 *ecs.TagResourceInput) (*ecs.TagResourceOutput, error)

+ func (fake *FakeECSClient) TagResourceArgsForCall(i int) *ecs.TagResourceInput

+ func (fake *FakeECSClient) TagResourceCallCount() int

+ func (fake *FakeECSClient) TagResourceCalls(stub func(*ecs.TagResourceInput) (*ecs.TagResourceOutput, error))

+ func (fake *FakeECSClient) TagResourceRequest(arg1 *ecs.TagResourceInput) (*request.Request, *ecs.TagResourceOutput)

+ func (fake *FakeECSClient) TagResourceRequestArgsForCall(i int) *ecs.TagResourceInput

+ func (fake *FakeECSClient) TagResourceRequestCallCount() int

+ func (fake *FakeECSClient) TagResourceRequestCalls(stub func(*ecs.TagResourceInput) (*request.Request, *ecs.TagResourceOutput))

+ func (fake *FakeECSClient) TagResourceRequestReturns(result1 *request.Request, result2 *ecs.TagResourceOutput)

+ func (fake *FakeECSClient) TagResourceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.TagResourceOutput)

+ func (fake *FakeECSClient) TagResourceReturns(result1 *ecs.TagResourceOutput, result2 error)

+ func (fake *FakeECSClient) TagResourceReturnsOnCall(i int, result1 *ecs.TagResourceOutput, result2 error)

+ func (fake *FakeECSClient) TagResourceWithContext(arg1 context.Context, arg2 *ecs.TagResourceInput, arg3 ...request.Option) (*ecs.TagResourceOutput, error)

+ func (fake *FakeECSClient) TagResourceWithContextArgsForCall(i int) (context.Context, *ecs.TagResourceInput, []request.Option)

+ func (fake *FakeECSClient) TagResourceWithContextCallCount() int

+ func (fake *FakeECSClient) TagResourceWithContextCalls(...)

+ func (fake *FakeECSClient) TagResourceWithContextReturns(result1 *ecs.TagResourceOutput, result2 error)

+ func (fake *FakeECSClient) TagResourceWithContextReturnsOnCall(i int, result1 *ecs.TagResourceOutput, result2 error)

+ func (fake *FakeECSClient) UntagResource(arg1 *ecs.UntagResourceInput) (*ecs.UntagResourceOutput, error)

+ func (fake *FakeECSClient) UntagResourceArgsForCall(i int) *ecs.UntagResourceInput

+ func (fake *FakeECSClient) UntagResourceCallCount() int

+ func (fake *FakeECSClient) UntagResourceCalls(stub func(*ecs.UntagResourceInput) (*ecs.UntagResourceOutput, error))

+ func (fake *FakeECSClient) UntagResourceRequest(arg1 *ecs.UntagResourceInput) (*request.Request, *ecs.UntagResourceOutput)

+ func (fake *FakeECSClient) UntagResourceRequestArgsForCall(i int) *ecs.UntagResourceInput

+ func (fake *FakeECSClient) UntagResourceRequestCallCount() int

+ func (fake *FakeECSClient) UntagResourceRequestCalls(...)

+ func (fake *FakeECSClient) UntagResourceRequestReturns(result1 *request.Request, result2 *ecs.UntagResourceOutput)

+ func (fake *FakeECSClient) UntagResourceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.UntagResourceOutput)

+ func (fake *FakeECSClient) UntagResourceReturns(result1 *ecs.UntagResourceOutput, result2 error)

+ func (fake *FakeECSClient) UntagResourceReturnsOnCall(i int, result1 *ecs.UntagResourceOutput, result2 error)

+ func (fake *FakeECSClient) UntagResourceWithContext(arg1 context.Context, arg2 *ecs.UntagResourceInput, arg3 ...request.Option) (*ecs.UntagResourceOutput, error)

+ func (fake *FakeECSClient) UntagResourceWithContextArgsForCall(i int) (context.Context, *ecs.UntagResourceInput, []request.Option)

+ func (fake *FakeECSClient) UntagResourceWithContextCallCount() int

+ func (fake *FakeECSClient) UntagResourceWithContextCalls(...)

+ func (fake *FakeECSClient) UntagResourceWithContextReturns(result1 *ecs.UntagResourceOutput, result2 error)

+ func (fake *FakeECSClient) UntagResourceWithContextReturnsOnCall(i int, result1 *ecs.UntagResourceOutput, result2 error)

+ func (fake *FakeECSClient) UpdateCapacityProvider(arg1 *ecs.UpdateCapacityProviderInput) (*ecs.UpdateCapacityProviderOutput, error)

+ func (fake *FakeECSClient) UpdateCapacityProviderArgsForCall(i int) *ecs.UpdateCapacityProviderInput

+ func (fake *FakeECSClient) UpdateCapacityProviderCallCount() int

+ func (fake *FakeECSClient) UpdateCapacityProviderCalls(...)

+ func (fake *FakeECSClient) UpdateCapacityProviderRequest(arg1 *ecs.UpdateCapacityProviderInput) (*request.Request, *ecs.UpdateCapacityProviderOutput)

+ func (fake *FakeECSClient) UpdateCapacityProviderRequestArgsForCall(i int) *ecs.UpdateCapacityProviderInput

+ func (fake *FakeECSClient) UpdateCapacityProviderRequestCallCount() int

+ func (fake *FakeECSClient) UpdateCapacityProviderRequestCalls(...)

+ func (fake *FakeECSClient) UpdateCapacityProviderRequestReturns(result1 *request.Request, result2 *ecs.UpdateCapacityProviderOutput)

+ func (fake *FakeECSClient) UpdateCapacityProviderRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.UpdateCapacityProviderOutput)

+ func (fake *FakeECSClient) UpdateCapacityProviderReturns(result1 *ecs.UpdateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) UpdateCapacityProviderReturnsOnCall(i int, result1 *ecs.UpdateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) UpdateCapacityProviderWithContext(arg1 context.Context, arg2 *ecs.UpdateCapacityProviderInput, ...) (*ecs.UpdateCapacityProviderOutput, error)

+ func (fake *FakeECSClient) UpdateCapacityProviderWithContextArgsForCall(i int) (context.Context, *ecs.UpdateCapacityProviderInput, []request.Option)

+ func (fake *FakeECSClient) UpdateCapacityProviderWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateCapacityProviderWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateCapacityProviderWithContextReturns(result1 *ecs.UpdateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) UpdateCapacityProviderWithContextReturnsOnCall(i int, result1 *ecs.UpdateCapacityProviderOutput, result2 error)

+ func (fake *FakeECSClient) UpdateClusterSettings(arg1 *ecs.UpdateClusterSettingsInput) (*ecs.UpdateClusterSettingsOutput, error)

+ func (fake *FakeECSClient) UpdateClusterSettingsArgsForCall(i int) *ecs.UpdateClusterSettingsInput

+ func (fake *FakeECSClient) UpdateClusterSettingsCallCount() int

+ func (fake *FakeECSClient) UpdateClusterSettingsCalls(...)

+ func (fake *FakeECSClient) UpdateClusterSettingsRequest(arg1 *ecs.UpdateClusterSettingsInput) (*request.Request, *ecs.UpdateClusterSettingsOutput)

+ func (fake *FakeECSClient) UpdateClusterSettingsRequestArgsForCall(i int) *ecs.UpdateClusterSettingsInput

+ func (fake *FakeECSClient) UpdateClusterSettingsRequestCallCount() int

+ func (fake *FakeECSClient) UpdateClusterSettingsRequestCalls(...)

+ func (fake *FakeECSClient) UpdateClusterSettingsRequestReturns(result1 *request.Request, result2 *ecs.UpdateClusterSettingsOutput)

+ func (fake *FakeECSClient) UpdateClusterSettingsRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.UpdateClusterSettingsOutput)

+ func (fake *FakeECSClient) UpdateClusterSettingsReturns(result1 *ecs.UpdateClusterSettingsOutput, result2 error)

+ func (fake *FakeECSClient) UpdateClusterSettingsReturnsOnCall(i int, result1 *ecs.UpdateClusterSettingsOutput, result2 error)

+ func (fake *FakeECSClient) UpdateClusterSettingsWithContext(arg1 context.Context, arg2 *ecs.UpdateClusterSettingsInput, ...) (*ecs.UpdateClusterSettingsOutput, error)

+ func (fake *FakeECSClient) UpdateClusterSettingsWithContextArgsForCall(i int) (context.Context, *ecs.UpdateClusterSettingsInput, []request.Option)

+ func (fake *FakeECSClient) UpdateClusterSettingsWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateClusterSettingsWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateClusterSettingsWithContextReturns(result1 *ecs.UpdateClusterSettingsOutput, result2 error)

+ func (fake *FakeECSClient) UpdateClusterSettingsWithContextReturnsOnCall(i int, result1 *ecs.UpdateClusterSettingsOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerAgent(arg1 *ecs.UpdateContainerAgentInput) (*ecs.UpdateContainerAgentOutput, error)

+ func (fake *FakeECSClient) UpdateContainerAgentArgsForCall(i int) *ecs.UpdateContainerAgentInput

+ func (fake *FakeECSClient) UpdateContainerAgentCallCount() int

+ func (fake *FakeECSClient) UpdateContainerAgentCalls(...)

+ func (fake *FakeECSClient) UpdateContainerAgentRequest(arg1 *ecs.UpdateContainerAgentInput) (*request.Request, *ecs.UpdateContainerAgentOutput)

+ func (fake *FakeECSClient) UpdateContainerAgentRequestArgsForCall(i int) *ecs.UpdateContainerAgentInput

+ func (fake *FakeECSClient) UpdateContainerAgentRequestCallCount() int

+ func (fake *FakeECSClient) UpdateContainerAgentRequestCalls(...)

+ func (fake *FakeECSClient) UpdateContainerAgentRequestReturns(result1 *request.Request, result2 *ecs.UpdateContainerAgentOutput)

+ func (fake *FakeECSClient) UpdateContainerAgentRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.UpdateContainerAgentOutput)

+ func (fake *FakeECSClient) UpdateContainerAgentReturns(result1 *ecs.UpdateContainerAgentOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerAgentReturnsOnCall(i int, result1 *ecs.UpdateContainerAgentOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerAgentWithContext(arg1 context.Context, arg2 *ecs.UpdateContainerAgentInput, ...) (*ecs.UpdateContainerAgentOutput, error)

+ func (fake *FakeECSClient) UpdateContainerAgentWithContextArgsForCall(i int) (context.Context, *ecs.UpdateContainerAgentInput, []request.Option)

+ func (fake *FakeECSClient) UpdateContainerAgentWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateContainerAgentWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateContainerAgentWithContextReturns(result1 *ecs.UpdateContainerAgentOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerAgentWithContextReturnsOnCall(i int, result1 *ecs.UpdateContainerAgentOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerInstancesState(arg1 *ecs.UpdateContainerInstancesStateInput) (*ecs.UpdateContainerInstancesStateOutput, error)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateArgsForCall(i int) *ecs.UpdateContainerInstancesStateInput

+ func (fake *FakeECSClient) UpdateContainerInstancesStateCallCount() int

+ func (fake *FakeECSClient) UpdateContainerInstancesStateCalls(...)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateRequest(arg1 *ecs.UpdateContainerInstancesStateInput) (*request.Request, *ecs.UpdateContainerInstancesStateOutput)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateRequestArgsForCall(i int) *ecs.UpdateContainerInstancesStateInput

+ func (fake *FakeECSClient) UpdateContainerInstancesStateRequestCallCount() int

+ func (fake *FakeECSClient) UpdateContainerInstancesStateRequestCalls(...)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateRequestReturns(result1 *request.Request, result2 *ecs.UpdateContainerInstancesStateOutput)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateRequestReturnsOnCall(i int, result1 *request.Request, ...)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateReturns(result1 *ecs.UpdateContainerInstancesStateOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateReturnsOnCall(i int, result1 *ecs.UpdateContainerInstancesStateOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateWithContext(arg1 context.Context, arg2 *ecs.UpdateContainerInstancesStateInput, ...) (*ecs.UpdateContainerInstancesStateOutput, error)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateWithContextArgsForCall(i int) (context.Context, *ecs.UpdateContainerInstancesStateInput, []request.Option)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateContainerInstancesStateWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateWithContextReturns(result1 *ecs.UpdateContainerInstancesStateOutput, result2 error)

+ func (fake *FakeECSClient) UpdateContainerInstancesStateWithContextReturnsOnCall(i int, result1 *ecs.UpdateContainerInstancesStateOutput, result2 error)

+ func (fake *FakeECSClient) UpdateService(arg1 *ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error)

+ func (fake *FakeECSClient) UpdateServiceArgsForCall(i int) *ecs.UpdateServiceInput

+ func (fake *FakeECSClient) UpdateServiceCallCount() int

+ func (fake *FakeECSClient) UpdateServiceCalls(stub func(*ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error))

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSet(arg1 *ecs.UpdateServicePrimaryTaskSetInput) (*ecs.UpdateServicePrimaryTaskSetOutput, error)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetArgsForCall(i int) *ecs.UpdateServicePrimaryTaskSetInput

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetCallCount() int

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetCalls(...)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetRequest(arg1 *ecs.UpdateServicePrimaryTaskSetInput) (*request.Request, *ecs.UpdateServicePrimaryTaskSetOutput)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetRequestArgsForCall(i int) *ecs.UpdateServicePrimaryTaskSetInput

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetRequestCallCount() int

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetRequestCalls(...)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetRequestReturns(result1 *request.Request, result2 *ecs.UpdateServicePrimaryTaskSetOutput)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetRequestReturnsOnCall(i int, result1 *request.Request, ...)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetReturns(result1 *ecs.UpdateServicePrimaryTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetReturnsOnCall(i int, result1 *ecs.UpdateServicePrimaryTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetWithContext(arg1 context.Context, arg2 *ecs.UpdateServicePrimaryTaskSetInput, ...) (*ecs.UpdateServicePrimaryTaskSetOutput, error)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetWithContextArgsForCall(i int) (context.Context, *ecs.UpdateServicePrimaryTaskSetInput, []request.Option)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetWithContextReturns(result1 *ecs.UpdateServicePrimaryTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServicePrimaryTaskSetWithContextReturnsOnCall(i int, result1 *ecs.UpdateServicePrimaryTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServiceRequest(arg1 *ecs.UpdateServiceInput) (*request.Request, *ecs.UpdateServiceOutput)

+ func (fake *FakeECSClient) UpdateServiceRequestArgsForCall(i int) *ecs.UpdateServiceInput

+ func (fake *FakeECSClient) UpdateServiceRequestCallCount() int

+ func (fake *FakeECSClient) UpdateServiceRequestCalls(...)

+ func (fake *FakeECSClient) UpdateServiceRequestReturns(result1 *request.Request, result2 *ecs.UpdateServiceOutput)

+ func (fake *FakeECSClient) UpdateServiceRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.UpdateServiceOutput)

+ func (fake *FakeECSClient) UpdateServiceReturns(result1 *ecs.UpdateServiceOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServiceReturnsOnCall(i int, result1 *ecs.UpdateServiceOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServiceWithContext(arg1 context.Context, arg2 *ecs.UpdateServiceInput, arg3 ...request.Option) (*ecs.UpdateServiceOutput, error)

+ func (fake *FakeECSClient) UpdateServiceWithContextArgsForCall(i int) (context.Context, *ecs.UpdateServiceInput, []request.Option)

+ func (fake *FakeECSClient) UpdateServiceWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateServiceWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateServiceWithContextReturns(result1 *ecs.UpdateServiceOutput, result2 error)

+ func (fake *FakeECSClient) UpdateServiceWithContextReturnsOnCall(i int, result1 *ecs.UpdateServiceOutput, result2 error)

+ func (fake *FakeECSClient) UpdateTaskSet(arg1 *ecs.UpdateTaskSetInput) (*ecs.UpdateTaskSetOutput, error)

+ func (fake *FakeECSClient) UpdateTaskSetArgsForCall(i int) *ecs.UpdateTaskSetInput

+ func (fake *FakeECSClient) UpdateTaskSetCallCount() int

+ func (fake *FakeECSClient) UpdateTaskSetCalls(stub func(*ecs.UpdateTaskSetInput) (*ecs.UpdateTaskSetOutput, error))

+ func (fake *FakeECSClient) UpdateTaskSetRequest(arg1 *ecs.UpdateTaskSetInput) (*request.Request, *ecs.UpdateTaskSetOutput)

+ func (fake *FakeECSClient) UpdateTaskSetRequestArgsForCall(i int) *ecs.UpdateTaskSetInput

+ func (fake *FakeECSClient) UpdateTaskSetRequestCallCount() int

+ func (fake *FakeECSClient) UpdateTaskSetRequestCalls(...)

+ func (fake *FakeECSClient) UpdateTaskSetRequestReturns(result1 *request.Request, result2 *ecs.UpdateTaskSetOutput)

+ func (fake *FakeECSClient) UpdateTaskSetRequestReturnsOnCall(i int, result1 *request.Request, result2 *ecs.UpdateTaskSetOutput)

+ func (fake *FakeECSClient) UpdateTaskSetReturns(result1 *ecs.UpdateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateTaskSetReturnsOnCall(i int, result1 *ecs.UpdateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateTaskSetWithContext(arg1 context.Context, arg2 *ecs.UpdateTaskSetInput, arg3 ...request.Option) (*ecs.UpdateTaskSetOutput, error)

+ func (fake *FakeECSClient) UpdateTaskSetWithContextArgsForCall(i int) (context.Context, *ecs.UpdateTaskSetInput, []request.Option)

+ func (fake *FakeECSClient) UpdateTaskSetWithContextCallCount() int

+ func (fake *FakeECSClient) UpdateTaskSetWithContextCalls(...)

+ func (fake *FakeECSClient) UpdateTaskSetWithContextReturns(result1 *ecs.UpdateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) UpdateTaskSetWithContextReturnsOnCall(i int, result1 *ecs.UpdateTaskSetOutput, result2 error)

+ func (fake *FakeECSClient) WaitUntilServicesInactive(arg1 *ecs.DescribeServicesInput) error

+ func (fake *FakeECSClient) WaitUntilServicesInactiveArgsForCall(i int) *ecs.DescribeServicesInput

+ func (fake *FakeECSClient) WaitUntilServicesInactiveCallCount() int

+ func (fake *FakeECSClient) WaitUntilServicesInactiveCalls(stub func(*ecs.DescribeServicesInput) error)

+ func (fake *FakeECSClient) WaitUntilServicesInactiveReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesInactiveReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesInactiveWithContext(arg1 context.Context, arg2 *ecs.DescribeServicesInput, ...) error

+ func (fake *FakeECSClient) WaitUntilServicesInactiveWithContextArgsForCall(i int) (context.Context, *ecs.DescribeServicesInput, []request.WaiterOption)

+ func (fake *FakeECSClient) WaitUntilServicesInactiveWithContextCallCount() int

+ func (fake *FakeECSClient) WaitUntilServicesInactiveWithContextCalls(...)

+ func (fake *FakeECSClient) WaitUntilServicesInactiveWithContextReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesInactiveWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesStable(arg1 *ecs.DescribeServicesInput) error

+ func (fake *FakeECSClient) WaitUntilServicesStableArgsForCall(i int) *ecs.DescribeServicesInput

+ func (fake *FakeECSClient) WaitUntilServicesStableCallCount() int

+ func (fake *FakeECSClient) WaitUntilServicesStableCalls(stub func(*ecs.DescribeServicesInput) error)

+ func (fake *FakeECSClient) WaitUntilServicesStableReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesStableReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesStableWithContext(arg1 context.Context, arg2 *ecs.DescribeServicesInput, ...) error

+ func (fake *FakeECSClient) WaitUntilServicesStableWithContextArgsForCall(i int) (context.Context, *ecs.DescribeServicesInput, []request.WaiterOption)

+ func (fake *FakeECSClient) WaitUntilServicesStableWithContextCallCount() int

+ func (fake *FakeECSClient) WaitUntilServicesStableWithContextCalls(...)

+ func (fake *FakeECSClient) WaitUntilServicesStableWithContextReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilServicesStableWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksRunning(arg1 *ecs.DescribeTasksInput) error

+ func (fake *FakeECSClient) WaitUntilTasksRunningArgsForCall(i int) *ecs.DescribeTasksInput

+ func (fake *FakeECSClient) WaitUntilTasksRunningCallCount() int

+ func (fake *FakeECSClient) WaitUntilTasksRunningCalls(stub func(*ecs.DescribeTasksInput) error)

+ func (fake *FakeECSClient) WaitUntilTasksRunningReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksRunningReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksRunningWithContext(arg1 context.Context, arg2 *ecs.DescribeTasksInput, ...) error

+ func (fake *FakeECSClient) WaitUntilTasksRunningWithContextArgsForCall(i int) (context.Context, *ecs.DescribeTasksInput, []request.WaiterOption)

+ func (fake *FakeECSClient) WaitUntilTasksRunningWithContextCallCount() int

+ func (fake *FakeECSClient) WaitUntilTasksRunningWithContextCalls(...)

+ func (fake *FakeECSClient) WaitUntilTasksRunningWithContextReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksRunningWithContextReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksStopped(arg1 *ecs.DescribeTasksInput) error

+ func (fake *FakeECSClient) WaitUntilTasksStoppedArgsForCall(i int) *ecs.DescribeTasksInput

+ func (fake *FakeECSClient) WaitUntilTasksStoppedCallCount() int

+ func (fake *FakeECSClient) WaitUntilTasksStoppedCalls(stub func(*ecs.DescribeTasksInput) error)

+ func (fake *FakeECSClient) WaitUntilTasksStoppedReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksStoppedReturnsOnCall(i int, result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksStoppedWithContext(arg1 context.Context, arg2 *ecs.DescribeTasksInput, ...) error

+ func (fake *FakeECSClient) WaitUntilTasksStoppedWithContextArgsForCall(i int) (context.Context, *ecs.DescribeTasksInput, []request.WaiterOption)

+ func (fake *FakeECSClient) WaitUntilTasksStoppedWithContextCallCount() int

+ func (fake *FakeECSClient) WaitUntilTasksStoppedWithContextCalls(...)

+ func (fake *FakeECSClient) WaitUntilTasksStoppedWithContextReturns(result1 error)

+ func (fake *FakeECSClient) WaitUntilTasksStoppedWithContextReturnsOnCall(i int, result1 error)