ECSClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ecs/ECSServiceClientModel.h>
#include <aws/ecs/ECS_EXPORTS.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::CreateExpressGatewayServiceOutcome CreateExpressGatewayService(
      const Model::CreateExpressGatewayServiceRequest& request) const;
 
  template <typename CreateExpressGatewayServiceRequestT = Model::CreateExpressGatewayServiceRequest>
  Model::CreateExpressGatewayServiceOutcomeCallable CreateExpressGatewayServiceCallable(
      const CreateExpressGatewayServiceRequestT& request) const {
    return SubmitCallable(&ECSClient::CreateExpressGatewayService, request);
  }
 
  template <typename CreateExpressGatewayServiceRequestT = Model::CreateExpressGatewayServiceRequest>
  void CreateExpressGatewayServiceAsync(const CreateExpressGatewayServiceRequestT& request,
                                        const CreateExpressGatewayServiceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECSClient::CreateExpressGatewayService, 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::DeleteExpressGatewayServiceOutcome DeleteExpressGatewayService(
      const Model::DeleteExpressGatewayServiceRequest& request) const;
 
  template <typename DeleteExpressGatewayServiceRequestT = Model::DeleteExpressGatewayServiceRequest>
  Model::DeleteExpressGatewayServiceOutcomeCallable DeleteExpressGatewayServiceCallable(
      const DeleteExpressGatewayServiceRequestT& request) const {
    return SubmitCallable(&ECSClient::DeleteExpressGatewayService, request);
  }
 
  template <typename DeleteExpressGatewayServiceRequestT = Model::DeleteExpressGatewayServiceRequest>
  void DeleteExpressGatewayServiceAsync(const DeleteExpressGatewayServiceRequestT& request,
                                        const DeleteExpressGatewayServiceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECSClient::DeleteExpressGatewayService, 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::DescribeExpressGatewayServiceOutcome DescribeExpressGatewayService(
      const Model::DescribeExpressGatewayServiceRequest& request) const;
 
  template <typename DescribeExpressGatewayServiceRequestT = Model::DescribeExpressGatewayServiceRequest>
  Model::DescribeExpressGatewayServiceOutcomeCallable DescribeExpressGatewayServiceCallable(
      const DescribeExpressGatewayServiceRequestT& request) const {
    return SubmitCallable(&ECSClient::DescribeExpressGatewayService, request);
  }
 
  template <typename DescribeExpressGatewayServiceRequestT = Model::DescribeExpressGatewayServiceRequest>
  void DescribeExpressGatewayServiceAsync(const DescribeExpressGatewayServiceRequestT& request,
                                          const DescribeExpressGatewayServiceResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECSClient::DescribeExpressGatewayService, 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::UpdateExpressGatewayServiceOutcome UpdateExpressGatewayService(
      const Model::UpdateExpressGatewayServiceRequest& request) const;
 
  template <typename UpdateExpressGatewayServiceRequestT = Model::UpdateExpressGatewayServiceRequest>
  Model::UpdateExpressGatewayServiceOutcomeCallable UpdateExpressGatewayServiceCallable(
      const UpdateExpressGatewayServiceRequestT& request) const {
    return SubmitCallable(&ECSClient::UpdateExpressGatewayService, request);
  }
 
  template <typename UpdateExpressGatewayServiceRequestT = Model::UpdateExpressGatewayServiceRequest>
  void UpdateExpressGatewayServiceAsync(const UpdateExpressGatewayServiceRequestT& request,
                                        const UpdateExpressGatewayServiceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECSClient::UpdateExpressGatewayService, 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