ECSClient.h

 
#pragma once
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ecs/ECSServiceClientModel.h>
 
namespace Aws
{
namespace ECS
{
  class AWS_ECS_API ECSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ECSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ECSClientConfiguration ClientConfigurationType;
      typedef ECSEndpointProvider EndpointProviderType;
 
        ECSClient(const Aws::ECS::ECSClientConfiguration& clientConfiguration = Aws::ECS::ECSClientConfiguration(),
                  std::shared_ptr<ECSEndpointProviderBase> endpointProvider = nullptr);
 
        ECSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<ECSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::ECS::ECSClientConfiguration& clientConfiguration = Aws::ECS::ECSClientConfiguration());
 
        ECSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<ECSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::ECS::ECSClientConfiguration& clientConfiguration = Aws::ECS::ECSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ECSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ECSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ECSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ECSClient();
 
        virtual Model::CreateCapacityProviderOutcome CreateCapacityProvider(const Model::CreateCapacityProviderRequest& request) const;
 
        template<typename CreateCapacityProviderRequestT = Model::CreateCapacityProviderRequest>
        Model::CreateCapacityProviderOutcomeCallable CreateCapacityProviderCallable(const CreateCapacityProviderRequestT& request) const
        {
            return SubmitCallable(&ECSClient::CreateCapacityProvider, request);
        }
 
        template<typename CreateCapacityProviderRequestT = Model::CreateCapacityProviderRequest>
        void CreateCapacityProviderAsync(const CreateCapacityProviderRequestT& request, const CreateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::CreateCapacityProvider, request, handler, context);
        }
 
        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request = {}) const;
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::CreateCluster, request);
        }
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        void CreateClusterAsync(const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateClusterRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::CreateCluster, request, handler, context);
        }
 
        virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const;
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        Model::CreateServiceOutcomeCallable CreateServiceCallable(const CreateServiceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::CreateService, request);
        }
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        void CreateServiceAsync(const CreateServiceRequestT& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::CreateService, request, handler, context);
        }
 
        virtual Model::CreateTaskSetOutcome CreateTaskSet(const Model::CreateTaskSetRequest& request) const;
 
        template<typename CreateTaskSetRequestT = Model::CreateTaskSetRequest>
        Model::CreateTaskSetOutcomeCallable CreateTaskSetCallable(const CreateTaskSetRequestT& request) const
        {
            return SubmitCallable(&ECSClient::CreateTaskSet, request);
        }
 
        template<typename CreateTaskSetRequestT = Model::CreateTaskSetRequest>
        void CreateTaskSetAsync(const CreateTaskSetRequestT& request, const CreateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::CreateTaskSet, request, handler, context);
        }
 
        virtual Model::DeleteAccountSettingOutcome DeleteAccountSetting(const Model::DeleteAccountSettingRequest& request) const;
 
        template<typename DeleteAccountSettingRequestT = Model::DeleteAccountSettingRequest>
        Model::DeleteAccountSettingOutcomeCallable DeleteAccountSettingCallable(const DeleteAccountSettingRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteAccountSetting, request);
        }
 
        template<typename DeleteAccountSettingRequestT = Model::DeleteAccountSettingRequest>
        void DeleteAccountSettingAsync(const DeleteAccountSettingRequestT& request, const DeleteAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteAccountSetting, request, handler, context);
        }
 
        virtual Model::DeleteAttributesOutcome DeleteAttributes(const Model::DeleteAttributesRequest& request) const;
 
        template<typename DeleteAttributesRequestT = Model::DeleteAttributesRequest>
        Model::DeleteAttributesOutcomeCallable DeleteAttributesCallable(const DeleteAttributesRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteAttributes, request);
        }
 
        template<typename DeleteAttributesRequestT = Model::DeleteAttributesRequest>
        void DeleteAttributesAsync(const DeleteAttributesRequestT& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteAttributes, request, handler, context);
        }
 
        virtual Model::DeleteCapacityProviderOutcome DeleteCapacityProvider(const Model::DeleteCapacityProviderRequest& request) const;
 
        template<typename DeleteCapacityProviderRequestT = Model::DeleteCapacityProviderRequest>
        Model::DeleteCapacityProviderOutcomeCallable DeleteCapacityProviderCallable(const DeleteCapacityProviderRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteCapacityProvider, request);
        }
 
        template<typename DeleteCapacityProviderRequestT = Model::DeleteCapacityProviderRequest>
        void DeleteCapacityProviderAsync(const DeleteCapacityProviderRequestT& request, const DeleteCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteCapacityProvider, request, handler, context);
        }
 
        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteCluster, request);
        }
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteCluster, request, handler, context);
        }
 
        virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const;
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const DeleteServiceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteService, request);
        }
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        void DeleteServiceAsync(const DeleteServiceRequestT& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteService, request, handler, context);
        }
 
        virtual Model::DeleteTaskDefinitionsOutcome DeleteTaskDefinitions(const Model::DeleteTaskDefinitionsRequest& request) const;
 
        template<typename DeleteTaskDefinitionsRequestT = Model::DeleteTaskDefinitionsRequest>
        Model::DeleteTaskDefinitionsOutcomeCallable DeleteTaskDefinitionsCallable(const DeleteTaskDefinitionsRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteTaskDefinitions, request);
        }
 
        template<typename DeleteTaskDefinitionsRequestT = Model::DeleteTaskDefinitionsRequest>
        void DeleteTaskDefinitionsAsync(const DeleteTaskDefinitionsRequestT& request, const DeleteTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteTaskDefinitions, request, handler, context);
        }
 
        virtual Model::DeleteTaskSetOutcome DeleteTaskSet(const Model::DeleteTaskSetRequest& request) const;
 
        template<typename DeleteTaskSetRequestT = Model::DeleteTaskSetRequest>
        Model::DeleteTaskSetOutcomeCallable DeleteTaskSetCallable(const DeleteTaskSetRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeleteTaskSet, request);
        }
 
        template<typename DeleteTaskSetRequestT = Model::DeleteTaskSetRequest>
        void DeleteTaskSetAsync(const DeleteTaskSetRequestT& request, const DeleteTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeleteTaskSet, request, handler, context);
        }
 
        virtual Model::DeregisterContainerInstanceOutcome DeregisterContainerInstance(const Model::DeregisterContainerInstanceRequest& request) const;
 
        template<typename DeregisterContainerInstanceRequestT = Model::DeregisterContainerInstanceRequest>
        Model::DeregisterContainerInstanceOutcomeCallable DeregisterContainerInstanceCallable(const DeregisterContainerInstanceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeregisterContainerInstance, request);
        }
 
        template<typename DeregisterContainerInstanceRequestT = Model::DeregisterContainerInstanceRequest>
        void DeregisterContainerInstanceAsync(const DeregisterContainerInstanceRequestT& request, const DeregisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeregisterContainerInstance, request, handler, context);
        }
 
        virtual Model::DeregisterTaskDefinitionOutcome DeregisterTaskDefinition(const Model::DeregisterTaskDefinitionRequest& request) const;
 
        template<typename DeregisterTaskDefinitionRequestT = Model::DeregisterTaskDefinitionRequest>
        Model::DeregisterTaskDefinitionOutcomeCallable DeregisterTaskDefinitionCallable(const DeregisterTaskDefinitionRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DeregisterTaskDefinition, request);
        }
 
        template<typename DeregisterTaskDefinitionRequestT = Model::DeregisterTaskDefinitionRequest>
        void DeregisterTaskDefinitionAsync(const DeregisterTaskDefinitionRequestT& request, const DeregisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DeregisterTaskDefinition, request, handler, context);
        }
 
        virtual Model::DescribeCapacityProvidersOutcome DescribeCapacityProviders(const Model::DescribeCapacityProvidersRequest& request = {}) const;
 
        template<typename DescribeCapacityProvidersRequestT = Model::DescribeCapacityProvidersRequest>
        Model::DescribeCapacityProvidersOutcomeCallable DescribeCapacityProvidersCallable(const DescribeCapacityProvidersRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::DescribeCapacityProviders, request);
        }
 
        template<typename DescribeCapacityProvidersRequestT = Model::DescribeCapacityProvidersRequest>
        void DescribeCapacityProvidersAsync(const DescribeCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCapacityProvidersRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::DescribeCapacityProviders, request, handler, context);
        }
 
        virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request = {}) const;
 
        template<typename DescribeClustersRequestT = Model::DescribeClustersRequest>
        Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const DescribeClustersRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::DescribeClusters, request);
        }
 
        template<typename DescribeClustersRequestT = Model::DescribeClustersRequest>
        void DescribeClustersAsync(const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClustersRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::DescribeClusters, request, handler, context);
        }
 
        virtual Model::DescribeContainerInstancesOutcome DescribeContainerInstances(const Model::DescribeContainerInstancesRequest& request) const;
 
        template<typename DescribeContainerInstancesRequestT = Model::DescribeContainerInstancesRequest>
        Model::DescribeContainerInstancesOutcomeCallable DescribeContainerInstancesCallable(const DescribeContainerInstancesRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeContainerInstances, request);
        }
 
        template<typename DescribeContainerInstancesRequestT = Model::DescribeContainerInstancesRequest>
        void DescribeContainerInstancesAsync(const DescribeContainerInstancesRequestT& request, const DescribeContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeContainerInstances, request, handler, context);
        }
 
        virtual Model::DescribeServiceDeploymentsOutcome DescribeServiceDeployments(const Model::DescribeServiceDeploymentsRequest& request) const;
 
        template<typename DescribeServiceDeploymentsRequestT = Model::DescribeServiceDeploymentsRequest>
        Model::DescribeServiceDeploymentsOutcomeCallable DescribeServiceDeploymentsCallable(const DescribeServiceDeploymentsRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeServiceDeployments, request);
        }
 
        template<typename DescribeServiceDeploymentsRequestT = Model::DescribeServiceDeploymentsRequest>
        void DescribeServiceDeploymentsAsync(const DescribeServiceDeploymentsRequestT& request, const DescribeServiceDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeServiceDeployments, request, handler, context);
        }
 
        virtual Model::DescribeServiceRevisionsOutcome DescribeServiceRevisions(const Model::DescribeServiceRevisionsRequest& request) const;
 
        template<typename DescribeServiceRevisionsRequestT = Model::DescribeServiceRevisionsRequest>
        Model::DescribeServiceRevisionsOutcomeCallable DescribeServiceRevisionsCallable(const DescribeServiceRevisionsRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeServiceRevisions, request);
        }
 
        template<typename DescribeServiceRevisionsRequestT = Model::DescribeServiceRevisionsRequest>
        void DescribeServiceRevisionsAsync(const DescribeServiceRevisionsRequestT& request, const DescribeServiceRevisionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeServiceRevisions, request, handler, context);
        }
 
        virtual Model::DescribeServicesOutcome DescribeServices(const Model::DescribeServicesRequest& request) const;
 
        template<typename DescribeServicesRequestT = Model::DescribeServicesRequest>
        Model::DescribeServicesOutcomeCallable DescribeServicesCallable(const DescribeServicesRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeServices, request);
        }
 
        template<typename DescribeServicesRequestT = Model::DescribeServicesRequest>
        void DescribeServicesAsync(const DescribeServicesRequestT& request, const DescribeServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeServices, request, handler, context);
        }
 
        virtual Model::DescribeTaskDefinitionOutcome DescribeTaskDefinition(const Model::DescribeTaskDefinitionRequest& request) const;
 
        template<typename DescribeTaskDefinitionRequestT = Model::DescribeTaskDefinitionRequest>
        Model::DescribeTaskDefinitionOutcomeCallable DescribeTaskDefinitionCallable(const DescribeTaskDefinitionRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeTaskDefinition, request);
        }
 
        template<typename DescribeTaskDefinitionRequestT = Model::DescribeTaskDefinitionRequest>
        void DescribeTaskDefinitionAsync(const DescribeTaskDefinitionRequestT& request, const DescribeTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeTaskDefinition, request, handler, context);
        }
 
        virtual Model::DescribeTaskSetsOutcome DescribeTaskSets(const Model::DescribeTaskSetsRequest& request) const;
 
        template<typename DescribeTaskSetsRequestT = Model::DescribeTaskSetsRequest>
        Model::DescribeTaskSetsOutcomeCallable DescribeTaskSetsCallable(const DescribeTaskSetsRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeTaskSets, request);
        }
 
        template<typename DescribeTaskSetsRequestT = Model::DescribeTaskSetsRequest>
        void DescribeTaskSetsAsync(const DescribeTaskSetsRequestT& request, const DescribeTaskSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeTaskSets, request, handler, context);
        }
 
        virtual Model::DescribeTasksOutcome DescribeTasks(const Model::DescribeTasksRequest& request) const;
 
        template<typename DescribeTasksRequestT = Model::DescribeTasksRequest>
        Model::DescribeTasksOutcomeCallable DescribeTasksCallable(const DescribeTasksRequestT& request) const
        {
            return SubmitCallable(&ECSClient::DescribeTasks, request);
        }
 
        template<typename DescribeTasksRequestT = Model::DescribeTasksRequest>
        void DescribeTasksAsync(const DescribeTasksRequestT& request, const DescribeTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::DescribeTasks, request, handler, context);
        }
 
        virtual Model::DiscoverPollEndpointOutcome DiscoverPollEndpoint(const Model::DiscoverPollEndpointRequest& request = {}) const;
 
        template<typename DiscoverPollEndpointRequestT = Model::DiscoverPollEndpointRequest>
        Model::DiscoverPollEndpointOutcomeCallable DiscoverPollEndpointCallable(const DiscoverPollEndpointRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::DiscoverPollEndpoint, request);
        }
 
        template<typename DiscoverPollEndpointRequestT = Model::DiscoverPollEndpointRequest>
        void DiscoverPollEndpointAsync(const DiscoverPollEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DiscoverPollEndpointRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::DiscoverPollEndpoint, request, handler, context);
        }
 
        virtual Model::ExecuteCommandOutcome ExecuteCommand(const Model::ExecuteCommandRequest& request) const;
 
        template<typename ExecuteCommandRequestT = Model::ExecuteCommandRequest>
        Model::ExecuteCommandOutcomeCallable ExecuteCommandCallable(const ExecuteCommandRequestT& request) const
        {
            return SubmitCallable(&ECSClient::ExecuteCommand, request);
        }
 
        template<typename ExecuteCommandRequestT = Model::ExecuteCommandRequest>
        void ExecuteCommandAsync(const ExecuteCommandRequestT& request, const ExecuteCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::ExecuteCommand, request, handler, context);
        }
 
        virtual Model::GetTaskProtectionOutcome GetTaskProtection(const Model::GetTaskProtectionRequest& request) const;
 
        template<typename GetTaskProtectionRequestT = Model::GetTaskProtectionRequest>
        Model::GetTaskProtectionOutcomeCallable GetTaskProtectionCallable(const GetTaskProtectionRequestT& request) const
        {
            return SubmitCallable(&ECSClient::GetTaskProtection, request);
        }
 
        template<typename GetTaskProtectionRequestT = Model::GetTaskProtectionRequest>
        void GetTaskProtectionAsync(const GetTaskProtectionRequestT& request, const GetTaskProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::GetTaskProtection, request, handler, context);
        }
 
        virtual Model::ListAccountSettingsOutcome ListAccountSettings(const Model::ListAccountSettingsRequest& request = {}) const;
 
        template<typename ListAccountSettingsRequestT = Model::ListAccountSettingsRequest>
        Model::ListAccountSettingsOutcomeCallable ListAccountSettingsCallable(const ListAccountSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListAccountSettings, request);
        }
 
        template<typename ListAccountSettingsRequestT = Model::ListAccountSettingsRequest>
        void ListAccountSettingsAsync(const ListAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccountSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListAccountSettings, request, handler, context);
        }
 
        virtual Model::ListAttributesOutcome ListAttributes(const Model::ListAttributesRequest& request) const;
 
        template<typename ListAttributesRequestT = Model::ListAttributesRequest>
        Model::ListAttributesOutcomeCallable ListAttributesCallable(const ListAttributesRequestT& request) const
        {
            return SubmitCallable(&ECSClient::ListAttributes, request);
        }
 
        template<typename ListAttributesRequestT = Model::ListAttributesRequest>
        void ListAttributesAsync(const ListAttributesRequestT& request, const ListAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::ListAttributes, request, handler, context);
        }
 
        virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListClusters, request);
        }
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        void ListClustersAsync(const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListClustersRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListClusters, request, handler, context);
        }
 
        virtual Model::ListContainerInstancesOutcome ListContainerInstances(const Model::ListContainerInstancesRequest& request = {}) const;
 
        template<typename ListContainerInstancesRequestT = Model::ListContainerInstancesRequest>
        Model::ListContainerInstancesOutcomeCallable ListContainerInstancesCallable(const ListContainerInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListContainerInstances, request);
        }
 
        template<typename ListContainerInstancesRequestT = Model::ListContainerInstancesRequest>
        void ListContainerInstancesAsync(const ListContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListContainerInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListContainerInstances, request, handler, context);
        }
 
        virtual Model::ListServiceDeploymentsOutcome ListServiceDeployments(const Model::ListServiceDeploymentsRequest& request) const;
 
        template<typename ListServiceDeploymentsRequestT = Model::ListServiceDeploymentsRequest>
        Model::ListServiceDeploymentsOutcomeCallable ListServiceDeploymentsCallable(const ListServiceDeploymentsRequestT& request) const
        {
            return SubmitCallable(&ECSClient::ListServiceDeployments, request);
        }
 
        template<typename ListServiceDeploymentsRequestT = Model::ListServiceDeploymentsRequest>
        void ListServiceDeploymentsAsync(const ListServiceDeploymentsRequestT& request, const ListServiceDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::ListServiceDeployments, request, handler, context);
        }
 
        virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListServices, request);
        }
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        void ListServicesAsync(const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServicesRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListServices, request, handler, context);
        }
 
        virtual Model::ListServicesByNamespaceOutcome ListServicesByNamespace(const Model::ListServicesByNamespaceRequest& request) const;
 
        template<typename ListServicesByNamespaceRequestT = Model::ListServicesByNamespaceRequest>
        Model::ListServicesByNamespaceOutcomeCallable ListServicesByNamespaceCallable(const ListServicesByNamespaceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::ListServicesByNamespace, request);
        }
 
        template<typename ListServicesByNamespaceRequestT = Model::ListServicesByNamespaceRequest>
        void ListServicesByNamespaceAsync(const ListServicesByNamespaceRequestT& request, const ListServicesByNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::ListServicesByNamespace, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTaskDefinitionFamiliesOutcome ListTaskDefinitionFamilies(const Model::ListTaskDefinitionFamiliesRequest& request = {}) const;
 
        template<typename ListTaskDefinitionFamiliesRequestT = Model::ListTaskDefinitionFamiliesRequest>
        Model::ListTaskDefinitionFamiliesOutcomeCallable ListTaskDefinitionFamiliesCallable(const ListTaskDefinitionFamiliesRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListTaskDefinitionFamilies, request);
        }
 
        template<typename ListTaskDefinitionFamiliesRequestT = Model::ListTaskDefinitionFamiliesRequest>
        void ListTaskDefinitionFamiliesAsync(const ListTaskDefinitionFamiliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTaskDefinitionFamiliesRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListTaskDefinitionFamilies, request, handler, context);
        }
 
        virtual Model::ListTaskDefinitionsOutcome ListTaskDefinitions(const Model::ListTaskDefinitionsRequest& request = {}) const;
 
        template<typename ListTaskDefinitionsRequestT = Model::ListTaskDefinitionsRequest>
        Model::ListTaskDefinitionsOutcomeCallable ListTaskDefinitionsCallable(const ListTaskDefinitionsRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListTaskDefinitions, request);
        }
 
        template<typename ListTaskDefinitionsRequestT = Model::ListTaskDefinitionsRequest>
        void ListTaskDefinitionsAsync(const ListTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTaskDefinitionsRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListTaskDefinitions, request, handler, context);
        }
 
        virtual Model::ListTasksOutcome ListTasks(const Model::ListTasksRequest& request = {}) const;
 
        template<typename ListTasksRequestT = Model::ListTasksRequest>
        Model::ListTasksOutcomeCallable ListTasksCallable(const ListTasksRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::ListTasks, request);
        }
 
        template<typename ListTasksRequestT = Model::ListTasksRequest>
        void ListTasksAsync(const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTasksRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::ListTasks, request, handler, context);
        }
 
        virtual Model::PutAccountSettingOutcome PutAccountSetting(const Model::PutAccountSettingRequest& request) const;
 
        template<typename PutAccountSettingRequestT = Model::PutAccountSettingRequest>
        Model::PutAccountSettingOutcomeCallable PutAccountSettingCallable(const PutAccountSettingRequestT& request) const
        {
            return SubmitCallable(&ECSClient::PutAccountSetting, request);
        }
 
        template<typename PutAccountSettingRequestT = Model::PutAccountSettingRequest>
        void PutAccountSettingAsync(const PutAccountSettingRequestT& request, const PutAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::PutAccountSetting, request, handler, context);
        }
 
        virtual Model::PutAccountSettingDefaultOutcome PutAccountSettingDefault(const Model::PutAccountSettingDefaultRequest& request) const;
 
        template<typename PutAccountSettingDefaultRequestT = Model::PutAccountSettingDefaultRequest>
        Model::PutAccountSettingDefaultOutcomeCallable PutAccountSettingDefaultCallable(const PutAccountSettingDefaultRequestT& request) const
        {
            return SubmitCallable(&ECSClient::PutAccountSettingDefault, request);
        }
 
        template<typename PutAccountSettingDefaultRequestT = Model::PutAccountSettingDefaultRequest>
        void PutAccountSettingDefaultAsync(const PutAccountSettingDefaultRequestT& request, const PutAccountSettingDefaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::PutAccountSettingDefault, request, handler, context);
        }
 
        virtual Model::PutAttributesOutcome PutAttributes(const Model::PutAttributesRequest& request) const;
 
        template<typename PutAttributesRequestT = Model::PutAttributesRequest>
        Model::PutAttributesOutcomeCallable PutAttributesCallable(const PutAttributesRequestT& request) const
        {
            return SubmitCallable(&ECSClient::PutAttributes, request);
        }
 
        template<typename PutAttributesRequestT = Model::PutAttributesRequest>
        void PutAttributesAsync(const PutAttributesRequestT& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::PutAttributes, request, handler, context);
        }
 
        virtual Model::PutClusterCapacityProvidersOutcome PutClusterCapacityProviders(const Model::PutClusterCapacityProvidersRequest& request) const;
 
        template<typename PutClusterCapacityProvidersRequestT = Model::PutClusterCapacityProvidersRequest>
        Model::PutClusterCapacityProvidersOutcomeCallable PutClusterCapacityProvidersCallable(const PutClusterCapacityProvidersRequestT& request) const
        {
            return SubmitCallable(&ECSClient::PutClusterCapacityProviders, request);
        }
 
        template<typename PutClusterCapacityProvidersRequestT = Model::PutClusterCapacityProvidersRequest>
        void PutClusterCapacityProvidersAsync(const PutClusterCapacityProvidersRequestT& request, const PutClusterCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::PutClusterCapacityProviders, request, handler, context);
        }
 
        virtual Model::RegisterContainerInstanceOutcome RegisterContainerInstance(const Model::RegisterContainerInstanceRequest& request = {}) const;
 
        template<typename RegisterContainerInstanceRequestT = Model::RegisterContainerInstanceRequest>
        Model::RegisterContainerInstanceOutcomeCallable RegisterContainerInstanceCallable(const RegisterContainerInstanceRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::RegisterContainerInstance, request);
        }
 
        template<typename RegisterContainerInstanceRequestT = Model::RegisterContainerInstanceRequest>
        void RegisterContainerInstanceAsync(const RegisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterContainerInstanceRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::RegisterContainerInstance, request, handler, context);
        }
 
        virtual Model::RegisterTaskDefinitionOutcome RegisterTaskDefinition(const Model::RegisterTaskDefinitionRequest& request) const;
 
        template<typename RegisterTaskDefinitionRequestT = Model::RegisterTaskDefinitionRequest>
        Model::RegisterTaskDefinitionOutcomeCallable RegisterTaskDefinitionCallable(const RegisterTaskDefinitionRequestT& request) const
        {
            return SubmitCallable(&ECSClient::RegisterTaskDefinition, request);
        }
 
        template<typename RegisterTaskDefinitionRequestT = Model::RegisterTaskDefinitionRequest>
        void RegisterTaskDefinitionAsync(const RegisterTaskDefinitionRequestT& request, const RegisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::RegisterTaskDefinition, request, handler, context);
        }
 
        virtual Model::RunTaskOutcome RunTask(const Model::RunTaskRequest& request) const;
 
        template<typename RunTaskRequestT = Model::RunTaskRequest>
        Model::RunTaskOutcomeCallable RunTaskCallable(const RunTaskRequestT& request) const
        {
            return SubmitCallable(&ECSClient::RunTask, request);
        }
 
        template<typename RunTaskRequestT = Model::RunTaskRequest>
        void RunTaskAsync(const RunTaskRequestT& request, const RunTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::RunTask, request, handler, context);
        }
 
        virtual Model::StartTaskOutcome StartTask(const Model::StartTaskRequest& request) const;
 
        template<typename StartTaskRequestT = Model::StartTaskRequest>
        Model::StartTaskOutcomeCallable StartTaskCallable(const StartTaskRequestT& request) const
        {
            return SubmitCallable(&ECSClient::StartTask, request);
        }
 
        template<typename StartTaskRequestT = Model::StartTaskRequest>
        void StartTaskAsync(const StartTaskRequestT& request, const StartTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::StartTask, request, handler, context);
        }
 
        virtual Model::StopServiceDeploymentOutcome StopServiceDeployment(const Model::StopServiceDeploymentRequest& request) const;
 
        template<typename StopServiceDeploymentRequestT = Model::StopServiceDeploymentRequest>
        Model::StopServiceDeploymentOutcomeCallable StopServiceDeploymentCallable(const StopServiceDeploymentRequestT& request) const
        {
            return SubmitCallable(&ECSClient::StopServiceDeployment, request);
        }
 
        template<typename StopServiceDeploymentRequestT = Model::StopServiceDeploymentRequest>
        void StopServiceDeploymentAsync(const StopServiceDeploymentRequestT& request, const StopServiceDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::StopServiceDeployment, request, handler, context);
        }
 
        virtual Model::StopTaskOutcome StopTask(const Model::StopTaskRequest& request) const;
 
        template<typename StopTaskRequestT = Model::StopTaskRequest>
        Model::StopTaskOutcomeCallable StopTaskCallable(const StopTaskRequestT& request) const
        {
            return SubmitCallable(&ECSClient::StopTask, request);
        }
 
        template<typename StopTaskRequestT = Model::StopTaskRequest>
        void StopTaskAsync(const StopTaskRequestT& request, const StopTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::StopTask, request, handler, context);
        }
 
        virtual Model::SubmitAttachmentStateChangesOutcome SubmitAttachmentStateChanges(const Model::SubmitAttachmentStateChangesRequest& request) const;
 
        template<typename SubmitAttachmentStateChangesRequestT = Model::SubmitAttachmentStateChangesRequest>
        Model::SubmitAttachmentStateChangesOutcomeCallable SubmitAttachmentStateChangesCallable(const SubmitAttachmentStateChangesRequestT& request) const
        {
            return SubmitCallable(&ECSClient::SubmitAttachmentStateChanges, request);
        }
 
        template<typename SubmitAttachmentStateChangesRequestT = Model::SubmitAttachmentStateChangesRequest>
        void SubmitAttachmentStateChangesAsync(const SubmitAttachmentStateChangesRequestT& request, const SubmitAttachmentStateChangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::SubmitAttachmentStateChanges, request, handler, context);
        }
 
        virtual Model::SubmitContainerStateChangeOutcome SubmitContainerStateChange(const Model::SubmitContainerStateChangeRequest& request = {}) const;
 
        template<typename SubmitContainerStateChangeRequestT = Model::SubmitContainerStateChangeRequest>
        Model::SubmitContainerStateChangeOutcomeCallable SubmitContainerStateChangeCallable(const SubmitContainerStateChangeRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::SubmitContainerStateChange, request);
        }
 
        template<typename SubmitContainerStateChangeRequestT = Model::SubmitContainerStateChangeRequest>
        void SubmitContainerStateChangeAsync(const SubmitContainerStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SubmitContainerStateChangeRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::SubmitContainerStateChange, request, handler, context);
        }
 
        virtual Model::SubmitTaskStateChangeOutcome SubmitTaskStateChange(const Model::SubmitTaskStateChangeRequest& request = {}) const;
 
        template<typename SubmitTaskStateChangeRequestT = Model::SubmitTaskStateChangeRequest>
        Model::SubmitTaskStateChangeOutcomeCallable SubmitTaskStateChangeCallable(const SubmitTaskStateChangeRequestT& request = {}) const
        {
            return SubmitCallable(&ECSClient::SubmitTaskStateChange, request);
        }
 
        template<typename SubmitTaskStateChangeRequestT = Model::SubmitTaskStateChangeRequest>
        void SubmitTaskStateChangeAsync(const SubmitTaskStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SubmitTaskStateChangeRequestT& request = {}) const
        {
            return SubmitAsync(&ECSClient::SubmitTaskStateChange, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCapacityProviderOutcome UpdateCapacityProvider(const Model::UpdateCapacityProviderRequest& request) const;
 
        template<typename UpdateCapacityProviderRequestT = Model::UpdateCapacityProviderRequest>
        Model::UpdateCapacityProviderOutcomeCallable UpdateCapacityProviderCallable(const UpdateCapacityProviderRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateCapacityProvider, request);
        }
 
        template<typename UpdateCapacityProviderRequestT = Model::UpdateCapacityProviderRequest>
        void UpdateCapacityProviderAsync(const UpdateCapacityProviderRequestT& request, const UpdateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateCapacityProvider, request, handler, context);
        }
 
        virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
 
        template<typename UpdateClusterRequestT = Model::UpdateClusterRequest>
        Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateCluster, request);
        }
 
        template<typename UpdateClusterRequestT = Model::UpdateClusterRequest>
        void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateCluster, request, handler, context);
        }
 
        virtual Model::UpdateClusterSettingsOutcome UpdateClusterSettings(const Model::UpdateClusterSettingsRequest& request) const;
 
        template<typename UpdateClusterSettingsRequestT = Model::UpdateClusterSettingsRequest>
        Model::UpdateClusterSettingsOutcomeCallable UpdateClusterSettingsCallable(const UpdateClusterSettingsRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateClusterSettings, request);
        }
 
        template<typename UpdateClusterSettingsRequestT = Model::UpdateClusterSettingsRequest>
        void UpdateClusterSettingsAsync(const UpdateClusterSettingsRequestT& request, const UpdateClusterSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateClusterSettings, request, handler, context);
        }
 
        virtual Model::UpdateContainerAgentOutcome UpdateContainerAgent(const Model::UpdateContainerAgentRequest& request) const;
 
        template<typename UpdateContainerAgentRequestT = Model::UpdateContainerAgentRequest>
        Model::UpdateContainerAgentOutcomeCallable UpdateContainerAgentCallable(const UpdateContainerAgentRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateContainerAgent, request);
        }
 
        template<typename UpdateContainerAgentRequestT = Model::UpdateContainerAgentRequest>
        void UpdateContainerAgentAsync(const UpdateContainerAgentRequestT& request, const UpdateContainerAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateContainerAgent, request, handler, context);
        }
 
        virtual Model::UpdateContainerInstancesStateOutcome UpdateContainerInstancesState(const Model::UpdateContainerInstancesStateRequest& request) const;
 
        template<typename UpdateContainerInstancesStateRequestT = Model::UpdateContainerInstancesStateRequest>
        Model::UpdateContainerInstancesStateOutcomeCallable UpdateContainerInstancesStateCallable(const UpdateContainerInstancesStateRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateContainerInstancesState, request);
        }
 
        template<typename UpdateContainerInstancesStateRequestT = Model::UpdateContainerInstancesStateRequest>
        void UpdateContainerInstancesStateAsync(const UpdateContainerInstancesStateRequestT& request, const UpdateContainerInstancesStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateContainerInstancesState, request, handler, context);
        }
 
        virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const;
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const UpdateServiceRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateService, request);
        }
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        void UpdateServiceAsync(const UpdateServiceRequestT& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateService, request, handler, context);
        }
 
        virtual Model::UpdateServicePrimaryTaskSetOutcome UpdateServicePrimaryTaskSet(const Model::UpdateServicePrimaryTaskSetRequest& request) const;
 
        template<typename UpdateServicePrimaryTaskSetRequestT = Model::UpdateServicePrimaryTaskSetRequest>
        Model::UpdateServicePrimaryTaskSetOutcomeCallable UpdateServicePrimaryTaskSetCallable(const UpdateServicePrimaryTaskSetRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateServicePrimaryTaskSet, request);
        }
 
        template<typename UpdateServicePrimaryTaskSetRequestT = Model::UpdateServicePrimaryTaskSetRequest>
        void UpdateServicePrimaryTaskSetAsync(const UpdateServicePrimaryTaskSetRequestT& request, const UpdateServicePrimaryTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateServicePrimaryTaskSet, request, handler, context);
        }
 
        virtual Model::UpdateTaskProtectionOutcome UpdateTaskProtection(const Model::UpdateTaskProtectionRequest& request) const;
 
        template<typename UpdateTaskProtectionRequestT = Model::UpdateTaskProtectionRequest>
        Model::UpdateTaskProtectionOutcomeCallable UpdateTaskProtectionCallable(const UpdateTaskProtectionRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateTaskProtection, request);
        }
 
        template<typename UpdateTaskProtectionRequestT = Model::UpdateTaskProtectionRequest>
        void UpdateTaskProtectionAsync(const UpdateTaskProtectionRequestT& request, const UpdateTaskProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateTaskProtection, request, handler, context);
        }
 
        virtual Model::UpdateTaskSetOutcome UpdateTaskSet(const Model::UpdateTaskSetRequest& request) const;
 
        template<typename UpdateTaskSetRequestT = Model::UpdateTaskSetRequest>
        Model::UpdateTaskSetOutcomeCallable UpdateTaskSetCallable(const UpdateTaskSetRequestT& request) const
        {
            return SubmitCallable(&ECSClient::UpdateTaskSet, request);
        }
 
        template<typename UpdateTaskSetRequestT = Model::UpdateTaskSetRequest>
        void UpdateTaskSetAsync(const UpdateTaskSetRequestT& request, const UpdateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ECSClient::UpdateTaskSet, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ECSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ECSClient>;
      void init(const ECSClientConfiguration& clientConfiguration);
 
      ECSClientConfiguration m_clientConfiguration;
      std::shared_ptr<ECSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ECS
} // namespace Aws